@zxyycom/vibe-check 0.0.1 → 0.0.3

package/src/package-checks/markdown-link-validation/resolver-engine.ts

@@ -1,7 +1,8 @@
 import { opendir } from "node:fs/promises";
 import path from "node:path";
 
-import { parseMarkdownLinkFacts } from "./markdown-parser.ts";
+import type { MarkdownLinkParseResult, ParsedMarkdownLinkFacts } from "./markdown-parser.ts";
+import { MarkdownLinkParseFactsSession } from "./parse-facts-cache.ts";
 import {
   directoryTarget,
   fileTargetDescriptor,
@@ -9,86 +10,64 @@ import {
   projectTarget
 } from "./target-descriptor.ts";
 import { probeEndpoint, probeRootContainedPath, readRegularFile } from "./filesystem-probes.ts";
+import { readRootContainedMarkdownSource } from "./source-reader.ts";
 import {
   anchorResolution,
   finding,
   isMarkdownPath,
-  isRootRelativePath,
   isWithinRoot,
   parseLocalDestination,
   sameRootRelativePath,
-  sourceUnavailable,
-  toSlashPath,
   unavailable,
   valid,
   type MarkdownLocalResolution,
   type MarkdownLocalResolutionRequest,
   type MarkdownLocalResolver,
   type MarkdownSafeTargetDescriptor,
-  type MarkdownSourceReadResult
+  type EndpointProbe
 } from "./local-resolution.ts";
+import type { ResolvedMarkdownLinkValidationOptions } from "./options.ts";
 
 export class LinkLocalResolver implements MarkdownLocalResolver {
   #targetReadCount = 0;
   readonly #canonicalProjectRoot: string;
+  readonly #parseFactsCache: MarkdownLinkParseFactsSession;
   readonly #maxTargetReads: number;
+  readonly #signal: AbortSignal;
+  readonly #targetFactMemo = new Map<string, Promise<ParsedMarkdownLinkFacts | undefined>>();
 
-  constructor(canonicalProjectRoot: string, maxTargetReads: number) {
+  constructor(
+    canonicalProjectRoot: string,
+    maxTargetReads: number,
+    cache: ResolvedMarkdownLinkValidationOptions["cache"],
+    signal: AbortSignal
+  ) {
     this.#canonicalProjectRoot = canonicalProjectRoot;
     this.#maxTargetReads = maxTargetReads;
+    this.#parseFactsCache = new MarkdownLinkParseFactsSession(cache);
+    this.#signal = signal;
   }
 
   get targetReadCount(): number {
     return this.#targetReadCount;
   }
 
-  async readSource(
-    rootRelativePath: string,
-    maxMarkdownBytes: number
-  ): Promise<MarkdownSourceReadResult> {
-    if (!isRootRelativePath(this.#canonicalProjectRoot, rootRelativePath)) {
-      return sourceUnavailable();
-    }
-
-    const sourcePath = path.resolve(this.#canonicalProjectRoot, rootRelativePath);
-    const rootProbe = await probeRootContainedPath(this.#canonicalProjectRoot, sourcePath);
-    if (
-      rootProbe.kind === "outside" ||
-      rootProbe.kind === "unavailable" ||
-      rootProbe.kind === "missing"
-    ) {
-      return sourceUnavailable();
-    }
-
-    const sourceBytes = await readRegularFile(rootProbe.absolutePath, maxMarkdownBytes);
-    if (!sourceBytes.ok) {
-      return sourceBytes.reason === "too-large"
-        ? Object.freeze({ ok: false as const, reason: "source-too-large" as const })
-        : sourceUnavailable();
-    }
-
-    let markdown: string;
-    try {
-      markdown = new TextDecoder("utf-8", { fatal: true }).decode(sourceBytes.bytes);
-    } catch {
-      return sourceUnavailable();
-    }
-
-    const parsed = parseMarkdownLinkFacts(markdown);
-    if (!parsed.ok) {
-      return Object.freeze({ ok: false as const, reason: "markdown-parse-failed" as const });
-    }
+  finalize(): Promise<void> {
+    return this.#parseFactsCache.finalize(this.#signal);
+  }
 
-    return Object.freeze({
-      ok: true as const,
-      source: Object.freeze({
-        path: toSlashPath(path.relative(this.#canonicalProjectRoot, sourcePath)),
-        facts: parsed.facts
-      })
+  readSource(rootRelativePath: string, maxMarkdownBytes: number) {
+    return readRootContainedMarkdownSource({
+      canonicalProjectRoot: this.#canonicalProjectRoot,
+      maxMarkdownBytes,
+      parseMarkdownBytes: (bytes) => this.#parseMarkdownBytes(bytes),
+      rootRelativePath,
+      signal: this.#signal
     });
   }
 
   async resolve(request: MarkdownLocalResolutionRequest): Promise<MarkdownLocalResolution> {
+    if (this.#signal.aborted) return unavailable("target-unavailable");
     const destination = parseLocalDestination(request.rawDestination);
     if (destination === "not-local") {
       return Object.freeze({ kind: "not-local" as const });
@@ -148,6 +127,7 @@ export class LinkLocalResolver implements MarkdownLocalResolver {
       return unavailable("target-read-limit-exceeded");
     }
     return this.resolveEndpoint(
+      rootProbe.endpoint ?? (await probeEndpoint(rootProbe.absolutePath)),
       rootProbe.absolutePath,
       fragment,
       request,
@@ -169,16 +149,22 @@ export class LinkLocalResolver implements MarkdownLocalResolver {
     if (!this.beginTargetValidation()) {
       return unavailable("target-read-limit-exceeded");
     }
-    return this.resolveEndpoint(targetPath, fragment, request, outsideProjectRootTarget());
+    return this.resolveEndpoint(
+      await probeEndpoint(targetPath),
+      targetPath,
+      fragment,
+      request,
+      outsideProjectRootTarget()
+    );
   }
 
   async resolveEndpoint(
+    endpoint: EndpointProbe,
     targetPath: string,
     fragment: string | null,
     request: MarkdownLocalResolutionRequest,
     target: MarkdownSafeTargetDescriptor
   ): Promise<MarkdownLocalResolution> {
-    const endpoint = await probeEndpoint(targetPath);
     if (endpoint.kind === "missing") {
       return request.requireExistingTargets ? finding("missing-target", target) : valid(target);
     }
@@ -208,21 +194,10 @@ export class LinkLocalResolver implements MarkdownLocalResolver {
       return finding("anchor-target-not-markdown", target);
     }
 
-    const targetMarkdown = await readRegularFile(targetPath, request.maxMarkdownBytes);
-    if (!targetMarkdown.ok) {
-      return unavailable("target-unavailable");
-    }
-    let decodedTarget: string;
-    try {
-      decodedTarget = new TextDecoder("utf-8", { fatal: true }).decode(targetMarkdown.bytes);
-    } catch {
-      return unavailable("target-unavailable");
-    }
-    const parsedTarget = parseMarkdownLinkFacts(decodedTarget);
-    if (!parsedTarget.ok) {
-      return unavailable("target-unavailable");
-    }
-    return anchorResolution(parsedTarget.facts.headings, fragment, target);
+    const facts = await this.#targetFacts(targetPath, request.maxMarkdownBytes);
+    return facts === undefined
+      ? unavailable("target-unavailable")
+      : anchorResolution(facts.headings, fragment, target);
   }
 
   async resolveDirectory(
@@ -231,6 +206,7 @@ export class LinkLocalResolver implements MarkdownLocalResolver {
     request: MarkdownLocalResolutionRequest,
     target: MarkdownSafeTargetDescriptor
   ): Promise<MarkdownLocalResolution> {
+    if (this.#signal.aborted) return unavailable("target-unavailable");
     if (fragment !== null) {
       return finding("anchor-on-directory", target);
     }
@@ -259,6 +235,40 @@ export class LinkLocalResolver implements MarkdownLocalResolver {
     return true;
   }
 
+  async #targetFacts(
+    targetPath: string,
+    maxMarkdownBytes: number
+  ): Promise<ParsedMarkdownLinkFacts | undefined> {
+    if (this.#signal.aborted) return undefined;
+    const key = JSON.stringify([targetPath, maxMarkdownBytes]);
+    const existing = this.#targetFactMemo.get(key);
+    if (existing !== undefined) return existing;
+
+    const pending = this.#readTargetFacts(targetPath, maxMarkdownBytes);
+    this.#targetFactMemo.set(key, pending);
+    const facts = await pending;
+    if (facts === undefined && this.#targetFactMemo.get(key) === pending) {
+      this.#targetFactMemo.delete(key);
+    }
+    return facts;
+  }
+
+  async #readTargetFacts(
+    targetPath: string,
+    maxMarkdownBytes: number
+  ): Promise<ParsedMarkdownLinkFacts | undefined> {
+    const targetMarkdown = await readRegularFile(targetPath, maxMarkdownBytes);
+    if (!targetMarkdown.ok || this.#signal.aborted) return undefined;
+    const parsed = await this.#parseMarkdownBytes(targetMarkdown.bytes);
+    return this.#signal.aborted || parsed === undefined || !parsed.ok ? undefined : parsed.facts;
+  }
+
+  async #parseMarkdownBytes(bytes: Uint8Array): Promise<MarkdownLinkParseResult | undefined> {
+    if (this.#signal.aborted) return undefined;
+    const parsed = await this.#parseFactsCache.parse(bytes, this.#signal);
+    return this.#signal.aborted ? undefined : parsed;
+  }
+
   resolveSameDocument(
     fragment: string | null,
     request: MarkdownLocalResolutionRequest

package/src/package-checks/markdown-link-validation/source-reader.ts

@@ -0,0 +1,86 @@
+import path from "node:path";
+
+import type { MarkdownLinkParseResult } from "./markdown-parser.ts";
+import { probeRootContainedPath, readRegularFile } from "./filesystem-probes.ts";
+import {
+  isRootRelativePath,
+  sourceUnavailable,
+  toSlashPath,
+  type MarkdownSourceReadResult
+} from "./local-resolution.ts";
+
+export interface RootContainedMarkdownSourceReadRequest {
+  readonly canonicalProjectRoot: string;
+  readonly maxMarkdownBytes: number;
+  readonly parseMarkdownBytes: (bytes: Uint8Array) => Promise<MarkdownLinkParseResult | undefined>;
+  readonly rootRelativePath: string;
+  readonly signal: AbortSignal;
+}
+
+type RootContainedSourceBytesRead =
+  | Readonly<{ readonly kind: "bytes"; readonly bytes: Uint8Array }>
+  | Readonly<{ readonly kind: "result"; readonly result: MarkdownSourceReadResult }>;
+
+/** Reads one authorized Markdown source without granting target-resolution behavior. */
+export async function readRootContainedMarkdownSource(
+  request: RootContainedMarkdownSourceReadRequest
+): Promise<MarkdownSourceReadResult> {
+  const sourcePath = authorizedRootRelativeSourcePath(request);
+  if (sourcePath === undefined) return sourceUnavailable();
+  const sourceRead = await readRootContainedSourceBytes(request, sourcePath);
+  if (sourceRead.kind === "result") return sourceRead.result;
+  return parseRootContainedSourceBytes(request, sourcePath, sourceRead.bytes);
+}
+
+function authorizedRootRelativeSourcePath(
+  request: RootContainedMarkdownSourceReadRequest
+): string | undefined {
+  if (request.signal.aborted) return undefined;
+  return isRootRelativePath(request.canonicalProjectRoot, request.rootRelativePath)
+    ? path.resolve(request.canonicalProjectRoot, request.rootRelativePath)
+    : undefined;
+}
+
+async function readRootContainedSourceBytes(
+  request: RootContainedMarkdownSourceReadRequest,
+  sourcePath: string
+): Promise<RootContainedSourceBytesRead> {
+  const rootProbe = await probeRootContainedPath(request.canonicalProjectRoot, sourcePath);
+  if (
+    rootProbe.kind === "outside" ||
+    rootProbe.kind === "unavailable" ||
+    rootProbe.kind === "missing"
+  ) {
+    return Object.freeze({ kind: "result" as const, result: sourceUnavailable() });
+  }
+  const sourceBytes = await readRegularFile(rootProbe.absolutePath, request.maxMarkdownBytes);
+  if (!sourceBytes.ok) {
+    return Object.freeze({
+      kind: "result" as const,
+      result:
+        sourceBytes.reason === "too-large"
+          ? Object.freeze({ ok: false as const, reason: "source-too-large" as const })
+          : sourceUnavailable()
+    });
+  }
+  return Object.freeze({ kind: "bytes" as const, bytes: sourceBytes.bytes });
+}
+
+async function parseRootContainedSourceBytes(
+  request: RootContainedMarkdownSourceReadRequest,
+  sourcePath: string,
+  sourceBytes: Uint8Array
+): Promise<MarkdownSourceReadResult> {
+  const parsed = await request.parseMarkdownBytes(sourceBytes);
+  if (request.signal.aborted || parsed === undefined) return sourceUnavailable();
+  if (!parsed.ok) {
+    return Object.freeze({ ok: false as const, reason: "markdown-parse-failed" as const });
+  }
+  return Object.freeze({
+    ok: true as const,
+    source: Object.freeze({
+      path: toSlashPath(path.relative(request.canonicalProjectRoot, sourcePath)),
+      facts: parsed.facts
+    })
+  });
+}

package/src/package-checks/markdown-link-validation/unavailable-reasons.ts

@@ -0,0 +1,42 @@
+import type {
+  MarkdownLocalResolutionReason,
+  MarkdownSourceReadFailureReason
+} from "./local-resolver.ts";
+
+/** `markdown-link-validation` whole-Check unavailable outcome 的稳定 reason code。 */
+export type MarkdownLinkValidationUnavailableReason =
+  | "invalid-options"
+  | "cancelled"
+  | "occurrence-limit-exceeded"
+  | "project-root-unavailable"
+  | MarkdownLocalResolutionReason
+  | MarkdownSourceReadFailureReason;
+
+const UNAVAILABLE_MESSAGES: Readonly<Record<MarkdownLinkValidationUnavailableReason, string>> = {
+  "invalid-options":
+    "markdownLinkValidation options are invalid; recreate the Check with markdownLinkValidation(options) or restore its complete resolved options.",
+  "project-root-unavailable":
+    "Markdown link validation could not resolve the project root; check that the path exists and is accessible.",
+  "source-unavailable":
+    "A selected Markdown source could not be collected, read, decoded, or contained safely; check the file source and permissions.",
+  "source-too-large":
+    "A selected Markdown source exceeds maxMarkdownBytes; narrow the file selection or raise the bounded limit.",
+  "markdown-parse-failed":
+    "A selected Markdown source could not be parsed completely; inspect that document's Markdown syntax and encoding.",
+  "invalid-local-destination":
+    "A local Markdown destination could not be parsed safely; inspect the affected link destination syntax.",
+  "target-unavailable":
+    "A local Markdown target could not be probed or read safely; check the target path, permissions, size, and encoding.",
+  "occurrence-limit-exceeded":
+    "Markdown link validation exceeded maxOccurrences; narrow the source selection or raise the bounded limit.",
+  "target-read-limit-exceeded":
+    "Markdown link validation exceeded maxTargetReads; narrow the source selection or raise the bounded limit.",
+  cancelled:
+    "Markdown link validation was cancelled before it could form a complete result; inspect the caller's cancellation reason and retry if appropriate."
+};
+
+export function markdownLinkUnavailableMessage(
+  reason: MarkdownLinkValidationUnavailableReason
+): string {
+  return UNAVAILABLE_MESSAGES[reason];
+}

package/src/package-checks/markdown-lint/adapter.ts

@@ -0,0 +1,167 @@
+import { lint } from "markdownlint/promise";
+
+import { snapshotClosedArray, snapshotClosedRecord } from "../../data-boundary/closed-values.ts";
+import { MARKDOWN_LINT_RULE_NAMES, type MarkdownLintRuleName } from "./options.ts";
+
+const FRONT_MATTER =
+  /((^---[^\S\r\n\u2028\u2029]*$[\s\S]+?^---\s*)|(^\+\+\+[^\S\r\n\u2028\u2029]*$[\s\S]+?^(\+\+\+|\.\.\.)\s*)|(^\{[^\S\r\n\u2028\u2029]*$[\s\S]+?^\}\s*))(\r\n|\r|\n|$)/m;
+
+const BACKEND_BY_RULE: Readonly<Record<MarkdownLintRuleName, string>> = {
+  "heading-increment": "MD001",
+  "no-reversed-links": "MD011",
+  "no-missing-space-atx": "MD018",
+  "fenced-code-language": "MD040",
+  "no-empty-links": "MD042",
+  "no-alt-text": "MD045",
+  "link-fragments": "MD051",
+  "reference-links-images": "MD052",
+  "table-column-count": "MD056"
+};
+
+export interface MarkdownLintBackendFinding {
+  readonly lineNumber: number;
+  readonly range: readonly [number, number] | null;
+  readonly rule: MarkdownLintRuleName;
+}
+
+/** Runs the fixed markdownlint Promise strings API and validates its raw protocol. */
+export async function lintMarkdownString(
+  sourcePath: string,
+  sourceText: string,
+  rules: readonly MarkdownLintRuleName[]
+): Promise<readonly MarkdownLintBackendFinding[] | "backend-failed" | "backend-protocol-invalid"> {
+  let raw: unknown;
+  try {
+    raw = await lint({
+      config: backendConfiguration(rules),
+      frontMatter: FRONT_MATTER,
+      noInlineConfig: true,
+      strings: { [sourcePath]: sourceText }
+    });
+  } catch {
+    return "backend-failed";
+  }
+  return parseBackendFindings(raw, sourcePath, sourceText, rules);
+}
+
+function backendConfiguration(
+  rules: readonly MarkdownLintRuleName[]
+): Readonly<Record<string, unknown>> {
+  const configuration: Record<string, unknown> = { default: false };
+  for (const rule of rules) configuration[BACKEND_BY_RULE[rule]] = configurationFor(rule);
+  if (rules.includes("reference-links-images") && !rules.includes("heading-increment")) {
+    configuration.MD001 = configurationFor("heading-increment");
+  }
+  return configuration;
+}
+
+function configurationFor(rule: MarkdownLintRuleName): unknown {
+  switch (rule) {
+    case "heading-increment":
+      return { front_matter_title: "^\\s*title\\s*[:=]" };
+    case "fenced-code-language":
+      return { allowed_languages: [], language_only: false };
+    case "link-fragments":
+      return { ignore_case: false, ignored_pattern: "" };
+    case "reference-links-images":
+      return { ignored_labels: ["x"], shortcut_syntax: false };
+    case "no-reversed-links":
+    case "no-missing-space-atx":
+    case "no-empty-links":
+    case "no-alt-text":
+    case "table-column-count":
+      return true;
+  }
+}
+
+function parseBackendFindings(
+  value: unknown,
+  sourcePath: string,
+  sourceText: string,
+  selectedRules: readonly MarkdownLintRuleName[]
+): readonly MarkdownLintBackendFinding[] | "backend-protocol-invalid" {
+  const result = snapshotClosedRecord(value);
+  if (
+    result === undefined ||
+    Object.keys(result).length !== 1 ||
+    !Object.hasOwn(result, sourcePath) ||
+    !Array.isArray(result[sourcePath])
+  )
+    return "backend-protocol-invalid";
+  const lines = sourceText.split(/\r\n|\r|\n/u);
+  const findings: MarkdownLintBackendFinding[] = [];
+  for (const rawFinding of result[sourcePath]) {
+    const finding = parseBackendFinding(rawFinding, lines);
+    if (finding === undefined) return "backend-protocol-invalid";
+    if (selectedRules.includes(finding.rule)) findings.push(finding);
+  }
+  return Object.freeze(findings);
+}
+
+function parseBackendFinding(
+  value: unknown,
+  lines: readonly string[]
+): MarkdownLintBackendFinding | undefined {
+  const fields = validatedBackendFindingFields(value, lines);
+  if (fields === undefined) return undefined;
+  const range = parseMarkdownLintRange(fields.errorRange, fields.line);
+  return range === undefined
+    ? undefined
+    : Object.freeze({ lineNumber: fields.lineNumber, range, rule: fields.rule });
+}
+
+function validatedBackendFindingFields(
+  value: unknown,
+  lines: readonly string[]
+):
+  | Readonly<{
+      readonly errorRange: unknown;
+      readonly line: string;
+      readonly lineNumber: number;
+      readonly rule: MarkdownLintRuleName;
+    }>
+  | undefined {
+  const finding = snapshotClosedRecord(value);
+  if (finding === undefined) return undefined;
+  const ruleNames = finding.ruleNames;
+  const lineNumber = finding.lineNumber;
+  if (
+    !Array.isArray(ruleNames) ||
+    typeof ruleNames[0] !== "string" ||
+    typeof lineNumber !== "number"
+  )
+    return undefined;
+  if (!Number.isSafeInteger(lineNumber) || lineNumber < 1 || lineNumber > lines.length)
+    return undefined;
+  const rule = ruleForBackend(ruleNames[0]);
+  const line = lines[lineNumber - 1];
+  return rule === undefined || line === undefined
+    ? undefined
+    : Object.freeze({ errorRange: finding.errorRange, line, lineNumber, rule });
+}
+
+function ruleForBackend(backendRule: string): MarkdownLintRuleName | undefined {
+  return MARKDOWN_LINT_RULE_NAMES.find((rule) => BACKEND_BY_RULE[rule] === backendRule);
+}
+
+/** Validates one backend or restored-cache range against the current source line. */
+export function parseMarkdownLintRange(
+  value: unknown,
+  line: string
+): readonly [number, number] | null | undefined {
+  if (value === null) return null;
+  const range = snapshotClosedArray(value);
+  if (range?.length !== 2) return undefined;
+  const [column, length] = range;
+  if (
+    typeof column !== "number" ||
+    typeof length !== "number" ||
+    !Number.isSafeInteger(column) ||
+    !Number.isSafeInteger(length) ||
+    column < 1 ||
+    length < 1 ||
+    column - 1 + length > line.length
+  )
+    return undefined;
+  return Object.freeze([column, length] as const);
+}

package/src/package-checks/markdown-lint/default-check.ts

@@ -0,0 +1,92 @@
+import { defineCheck, type TypedCheckWithOptions } from "../../check/check.ts";
+import {
+  resolvePackageCheckAuthoringInput,
+  type PackageCheckIdentityInput
+} from "../check-authoring.ts";
+import { MARKDOWN_LINT_CHECK_DEFINITION, executeMarkdownLint } from "./execution.ts";
+import { parseMarkdownLintData } from "./final-data.ts";
+import type { MarkdownLintOptions, ResolvedMarkdownLintOptions } from "./options.ts";
+import { resolveMarkdownLintOptions } from "./options-resolution.ts";
+import { validMarkdownLintOptions } from "./options-validation.ts";
+
+/**
+ * 构造使用稳定闭合规则与受限输入的 Markdown 结构检查。
+ * 精确 findingWaivers 只在完整 traversal 后应用；原 Finding、计数与缓存 facts 保留。
+ *
+ * @param options - 省略时采用八项 recommended 规则；非空 rules 数组完整替换该集合。
+ * @returns 使用默认或指定 checkId 的 typed Check，携带完整冻结 options、parser 与执行逻辑。
+ * @throws {TypeError} options 含未知字段、未知/重复规则、非法 limits 或 findingWaivers 时抛出。
+ * @example 最小用法
+ * ```ts
+ * import { defineConfig, markdownLint, run } from "@zxyycom/vibe-check";
+ *
+ * const check = markdownLint({ findingPolicy: "blocking" });
+ * const definition = defineConfig({
+ *   checks: [check],
+ *   outputs: {
+ *     diagnosticLogging: { enabled: false },
+ *     machinePublication: { enabled: false },
+ *     progressRendering: { enabled: false }
+ *   }
+ * });
+ *
+ * const result = await run(definition);
+ * if (result.kind !== "completed") throw new Error(`Run did not complete: ${result.kind}`);
+ * const outcome = result.snapshot.checks.find(({ checkId }) => checkId === check.checkId)?.outcome;
+ * if (outcome?.status !== "passed" && outcome?.status !== "not-applicable") {
+ *   throw new Error(`Markdown lint did not pass: ${outcome?.status ?? "no outcome"}`);
+ * }
+ * if (outcome.status === "not-applicable") console.warn("No Markdown input selected; no lint evidence.");
+ * ```
+ */
+export function markdownLint(
+  options?: MarkdownLintOptions<"markdown-lint">
+): TypedCheckWithOptions<
+  "markdown-lint",
+  ResolvedMarkdownLintOptions,
+  typeof parseMarkdownLintData
+>;
+export function markdownLint<const Id extends string>(
+  options: MarkdownLintOptions<Id> & PackageCheckIdentityInput<Id>
+): TypedCheckWithOptions<Id, ResolvedMarkdownLintOptions, typeof parseMarkdownLintData>;
+export function markdownLint(
+  options: MarkdownLintOptions
+): TypedCheckWithOptions<string, ResolvedMarkdownLintOptions, typeof parseMarkdownLintData>;
+export function markdownLint(
+  options: MarkdownLintOptions = {}
+): TypedCheckWithOptions<string, ResolvedMarkdownLintOptions, typeof parseMarkdownLintData> {
+  const input = resolvePackageCheckAuthoringInput(
+    options,
+    ["files", "findingPolicy", "findingWaivers", "rules", "limits", "cache"],
+    MARKDOWN_LINT_CHECK_DEFINITION
+  );
+  if (input === undefined) {
+    throw new TypeError("markdownLint options must match the documented closed policy");
+  }
+  const resolvedOptions = resolveMarkdownLintOptions(input.domainOptions);
+  if (resolvedOptions === undefined) {
+    throw new TypeError("markdownLint options must match the documented closed policy");
+  }
+  return defineCheck({
+    ...input.definition,
+    execute: executeMarkdownLint,
+    parseData: parseMarkdownLintData,
+    prepare: (preparedOptions) =>
+      validMarkdownLintOptions(preparedOptions)
+        ? { status: "success", preparedOptions }
+        : {
+            status: "failure",
+            action: "block",
+            reason: { code: "invalid-options" },
+            messages: [
+              {
+                code: "invalid-options",
+                level: "error",
+                message:
+                  "markdownLint options are invalid; recreate the Check with markdownLint(options) or restore its complete resolved options."
+              }
+            ]
+          },
+    options: resolvedOptions
+  });
+}