@zxyycom/vibe-check 0.0.2 → 0.0.3

package/src/package-checks/json-schema-validation/schema-policy.ts

@@ -108,8 +108,11 @@ function inspectDirectSchemaPolicy(
 ): SchemaCompileReason | undefined {
   if (Object.hasOwn(schemaObject, "$async")) return "invalid-schema";
   if (hasUnsupportedReferenceKeyword(schemaObject)) return "unsupported-reference";
-  if (Object.hasOwn(schemaObject, "$id") && !permittedNestedIdentifier(schemaObject.$id)) {
-    return "unsupported-reference";
+  if (Object.hasOwn(schemaObject, "$id")) {
+    const identifier = schemaObject.$id;
+    if (identifier === undefined || !permittedNestedIdentifier(identifier)) {
+      return "unsupported-reference";
+    }
   }
   return hasInvalidReferenceValue(schemaObject) ? "unsupported-reference" : undefined;
 }
@@ -123,9 +126,11 @@ function hasUnsupportedReferenceKeyword(
 function hasInvalidReferenceValue(
   schemaObject: Readonly<Record<string, StrictJsonValue>>
 ): boolean {
-  return ["$ref", "$schema"].some(
-    (key) => Object.hasOwn(schemaObject, key) && !permittedReference(schemaObject[key])
-  );
+  return ["$ref", "$schema"].some((key) => {
+    if (!Object.hasOwn(schemaObject, key)) return false;
+    const reference = schemaObject[key];
+    return reference === undefined || !permittedReference(reference);
+  });
 }
 
 function inspectNestedSchemaPolicies(

package/src/package-checks/json-validation/default-check.ts

@@ -1,4 +1,8 @@
 import { defineCheck, type TypedCheckWithOptions } from "../../check/check.ts";
+import {
+  resolvePackageCheckAuthoringInput,
+  type PackageCheckIdentityInput
+} from "../check-authoring.ts";
 import { JSON_VALIDATION_CHECK_DEFINITION, executeJsonValidation } from "./json-validation.ts";
 import { parseJsonValidationData } from "./final-data.ts";
 import type { JsonValidationOptions, ResolvedJsonValidationOptions } from "./options.ts";
@@ -13,21 +17,38 @@ import { validJsonValidationOptions } from "./options-validation.ts";
  * @throws {TypeError} input 含未知字段、非法文件选择或非法 byte limit 时抛出。
  */
 export function jsonValidation(
-  options: JsonValidationOptions = {}
+  options?: JsonValidationOptions<"json-validation">
 ): TypedCheckWithOptions<
   "json-validation",
   ResolvedJsonValidationOptions,
   typeof parseJsonValidationData
-> {
-  const resolvedOptions = resolveJsonValidationOptions(options);
+>;
+export function jsonValidation<const Id extends string>(
+  options: JsonValidationOptions<Id> & PackageCheckIdentityInput<Id>
+): TypedCheckWithOptions<Id, ResolvedJsonValidationOptions, typeof parseJsonValidationData>;
+export function jsonValidation(
+  options: JsonValidationOptions
+): TypedCheckWithOptions<string, ResolvedJsonValidationOptions, typeof parseJsonValidationData>;
+export function jsonValidation(
+  options: JsonValidationOptions = {}
+): TypedCheckWithOptions<string, ResolvedJsonValidationOptions, typeof parseJsonValidationData> {
+  const input = resolvePackageCheckAuthoringInput(
+    options,
+    ["files", "maximumBytes"],
+    JSON_VALIDATION_CHECK_DEFINITION
+  );
+  if (input === undefined) {
+    throw new TypeError("jsonValidation options must match the documented closed policy");
+  }
+  const resolvedOptions = resolveJsonValidationOptions(input.domainOptions);
   if (resolvedOptions === undefined) {
     throw new TypeError("jsonValidation options must match the documented closed policy");
   }
   return defineCheck({
-    ...JSON_VALIDATION_CHECK_DEFINITION,
-    execution: executeJsonValidation,
+    ...input.definition,
+    execute: executeJsonValidation,
     parseData: parseJsonValidationData,
-    preflight: (preparedOptions) =>
+    prepare: (preparedOptions) =>
       validJsonValidationOptions(preparedOptions)
         ? { status: "success", preparedOptions }
         : {

package/src/package-checks/json-validation/options.ts

@@ -1,10 +1,13 @@
+import type { PackageCheckAuthoringOptions } from "../check-authoring.ts";
 import type {
   ProjectFileSelection,
   ProjectFileSelectionOptions
 } from "../project-files/configuration.ts";
 
 /** `jsonValidation(options?)` 接受的可省略 authoring policy。 */
-export interface JsonValidationOptions {
+export interface JsonValidationOptions<
+  Id extends string = string
+> extends PackageCheckAuthoringOptions<Id> {
   /** 参与本 Check 的 repository-file selection；省略字段使用 package defaults。 */
   readonly files?: ProjectFileSelectionOptions;
   /** 单个 JSON document 允许的最大 raw byte 数；省略时为 1 MiB。 */

package/src/package-checks/local-cache-options.ts

@@ -0,0 +1,40 @@
+import { isAbsolute } from "node:path";
+
+import {
+  hasExactPlainRecordKeys,
+  snapshotClosedRecord,
+  snapshotExactClosedRecord
+} from "../data-boundary/closed-values.ts";
+
+/** Shared closed grammar for an explicitly owned, deletable local cache directory. */
+export type LocalCacheOptions =
+  | Readonly<{ readonly enabled: false }>
+  | Readonly<{ readonly enabled: true; readonly directory: string }>;
+
+export function resolveOptionalLocalCacheOptions(value: unknown): LocalCacheOptions | undefined {
+  if (value === undefined) return Object.freeze({ enabled: false as const });
+  const cache = snapshotClosedRecord(value);
+  if (cache === undefined) return undefined;
+  if (hasExactPlainRecordKeys(cache, ["enabled"]) && cache.enabled === false)
+    return Object.freeze({ enabled: false as const });
+  if (
+    hasExactPlainRecordKeys(cache, ["enabled", "directory"]) &&
+    cache.enabled === true &&
+    typeof cache.directory === "string"
+  )
+    return Object.freeze({ enabled: true as const, directory: cache.directory });
+  return undefined;
+}
+
+export function validLocalCacheOptions(value: unknown): value is LocalCacheOptions {
+  const disabled = snapshotExactClosedRecord(value, ["enabled"]);
+  if (disabled?.enabled === false) return true;
+  const enabled = snapshotExactClosedRecord(value, ["enabled", "directory"]);
+  return (
+    enabled?.enabled === true &&
+    typeof enabled.directory === "string" &&
+    enabled.directory.length > 0 &&
+    !enabled.directory.includes("\0") &&
+    isAbsolute(enabled.directory)
+  );
+}

package/src/package-checks/maintenance-reminders/maintenance-reminders.ts

@@ -4,6 +4,11 @@ import {
   type CheckResult,
   type TypedCheckWithOptions
 } from "../../check/check.ts";
+import {
+  resolvePackageCheckAuthoringInput,
+  type PackageCheckAuthoringOptions,
+  type PackageCheckIdentityInput
+} from "../check-authoring.ts";
 import {
   MAINTENANCE_REMINDER_UNAVAILABLE_REASON,
   parseMaintenanceRemindersData,
@@ -59,6 +64,14 @@ export interface MaintenanceReminderOptions {
   }>;
 }
 
+/** `maintenanceReminders` 的对象式构造输入，组合提醒政策与项目 Check 声明。 */
+export interface MaintenanceRemindersInput<
+  Id extends string = string
+> extends PackageCheckAuthoringOptions<Id> {
+  /** 保留作者声明顺序的提醒政策条目。 */
+  readonly entries: readonly MaintenanceReminder[];
+}
+
 /** `maintenance-reminders` whole-Check unavailable outcome 的稳定 reason code。 */
 export type MaintenanceRemindersUnavailableCode =
   (typeof WHOLE_CHECK_UNAVAILABLE_CODE)[keyof typeof WHOLE_CHECK_UNAVAILABLE_CODE];
@@ -93,9 +106,9 @@ export type ReminderMeasurement =
   | Readonly<{ readonly kind: "succeeded"; readonly value: ReminderEvaluation }>;
 
 /**
- * 创建一个固定 ID 的普通 Check，并在其局部最终数据中评估多条维护提醒。
+ * 创建一个维护提醒普通 Check，并在其局部最终数据中评估多条维护提醒。
  *
- * @remarks 构造函数只接收项目无法可靠推断的提醒政策；它补齐 Git 可执行文件、身份、可见性和直接执行逻辑。返回值仍是普通 Check，可按现有原生对象组合规则替换完整 `options` 分支。
+ * @remarks 传入 entries 数组会保留默认 identity；对象输入可同时声明项目 Check 字段。构造函数补齐 Git 可执行文件、默认展示和直接执行逻辑，返回值仍是普通 Check，可按现有原生对象组合规则替换完整 `options` 分支。
  * @example 创建一个单一 Check 的维护提醒
  * ```ts
  * import { defineConfig, maintenanceReminders, run } from "@zxyycom/vibe-check";
@@ -136,13 +149,55 @@ export function maintenanceReminders(
   typeof MAINTENANCE_REMINDERS_CHECK_ID,
   MaintenanceReminderOptions,
   typeof parseMaintenanceRemindersData
-> {
+>;
+export function maintenanceReminders(
+  input: MaintenanceRemindersInput<typeof MAINTENANCE_REMINDERS_CHECK_ID>
+): TypedCheckWithOptions<
+  typeof MAINTENANCE_REMINDERS_CHECK_ID,
+  MaintenanceReminderOptions,
+  typeof parseMaintenanceRemindersData
+>;
+export function maintenanceReminders<const Id extends string>(
+  input: MaintenanceRemindersInput<Id> & PackageCheckIdentityInput<Id>
+): TypedCheckWithOptions<Id, MaintenanceReminderOptions, typeof parseMaintenanceRemindersData>;
+export function maintenanceReminders(
+  input: MaintenanceRemindersInput
+): TypedCheckWithOptions<string, MaintenanceReminderOptions, typeof parseMaintenanceRemindersData>;
+export function maintenanceReminders(
+  input: readonly MaintenanceReminder[] | MaintenanceRemindersInput
+): TypedCheckWithOptions<string, MaintenanceReminderOptions, typeof parseMaintenanceRemindersData> {
+  if (isMaintenanceReminderEntries(input)) {
+    return createMaintenanceRemindersCheck(
+      {
+        checkId: MAINTENANCE_REMINDERS_CHECK_ID,
+        displayName: "Maintenance reminders",
+        omitQuietPassedRow: true
+      },
+      input
+    );
+  }
+  const resolvedInput = resolveMaintenanceRemindersInput(input);
+  if (resolvedInput === undefined) {
+    throw new TypeError(
+      "maintenanceReminders input must be entries or a closed { entries, checkId?, displayName?, enabledByFlags?, checks?, dependsOn?, observes?, maxParallel?, admissionPriority?, mutex?, resourceClaims?, omitQuietPassedRow? } object"
+    );
+  }
+  return createMaintenanceRemindersCheck(resolvedInput.definition, resolvedInput.entries);
+}
+
+type PackageCheckDefinition<Id extends string> = NonNullable<
+  ReturnType<typeof resolvePackageCheckAuthoringInput<Id>>
+>["definition"];
+
+function createMaintenanceRemindersCheck<Id extends string>(
+  definition: PackageCheckDefinition<Id>,
+  entries: readonly MaintenanceReminder[]
+): TypedCheckWithOptions<Id, MaintenanceReminderOptions, typeof parseMaintenanceRemindersData> {
   return defineCheck({
-    checkId: MAINTENANCE_REMINDERS_CHECK_ID,
-    displayName: "Maintenance reminders",
-    execution: executeMaintenanceReminders,
+    ...definition,
+    execute: executeMaintenanceReminders,
     parseData: parseMaintenanceRemindersData,
-    preflight: (options) =>
+    prepare: (options) =>
       validMaintenanceReminderOptions(options)
         ? { status: "success", preparedOptions: options }
         : {
@@ -161,9 +216,34 @@ export function maintenanceReminders(
     options: {
       entries,
       git: { executable: "git" }
-    },
-    visibility: "attention"
+    }
+  });
+}
+
+function isMaintenanceReminderEntries(
+  input: readonly MaintenanceReminder[] | MaintenanceRemindersInput
+): input is readonly MaintenanceReminder[] {
+  return Array.isArray(input);
+}
+
+function resolveMaintenanceRemindersInput<Id extends string>(
+  input: MaintenanceRemindersInput<Id>
+):
+  | Readonly<{
+      readonly definition: PackageCheckDefinition<Id>;
+      readonly entries: readonly MaintenanceReminder[];
+    }>
+  | undefined {
+  const resolved = resolvePackageCheckAuthoringInput(input, ["entries"], {
+    checkId: MAINTENANCE_REMINDERS_CHECK_ID,
+    displayName: "Maintenance reminders",
+    omitQuietPassedRow: true
   });
+  if (resolved === undefined) return undefined;
+  const entries = resolved.domainOptions.entries;
+  if (!Array.isArray(entries)) return undefined;
+  const reminderEntries: readonly MaintenanceReminder[] = entries;
+  return Object.freeze({ definition: resolved.definition, entries: reminderEntries });
 }
 
 /** 在普通对象组合后验证完整的选项形状。 */

package/src/package-checks/maintenance-reminders/maintenance-support.ts

@@ -51,9 +51,9 @@ export async function runGit(input: {
       }
       stdout += text;
     });
-    child.once("error", () =>
-      settle(input.signal.aborted ? { kind: "cancelled" } : { kind: "failed" })
-    );
+    child.once("error", () => {
+      settle(input.signal.aborted ? { kind: "cancelled" } : { kind: "failed" });
+    });
     child.once("close", (status) => {
       if (input.signal.aborted) {
         settle({ kind: "cancelled" });

package/src/package-checks/markdown-link-validation/default-check.ts

@@ -1,4 +1,8 @@
 import { defineCheck, type TypedCheckWithOptions } from "../../check/check.ts";
+import {
+  resolvePackageCheckAuthoringInput,
+  type PackageCheckIdentityInput
+} from "../check-authoring.ts";
 import {
   MARKDOWN_LINK_VALIDATION_CHECK_DEFINITION,
   executeMarkdownLinkValidation
@@ -41,21 +45,60 @@ import { validMarkdownLinkValidationOptions } from "./options-validation.ts";
  * ```
  */
 export function markdownLinkValidation(
-  options: MarkdownLinkValidationOptions = {}
+  options?: MarkdownLinkValidationOptions<"markdown-link-validation">
 ): TypedCheckWithOptions<
   "markdown-link-validation",
   ResolvedMarkdownLinkValidationOptions,
   typeof parseMarkdownLinkValidationData
+>;
+export function markdownLinkValidation<const Id extends string>(
+  options: MarkdownLinkValidationOptions<Id> & PackageCheckIdentityInput<Id>
+): TypedCheckWithOptions<
+  Id,
+  ResolvedMarkdownLinkValidationOptions,
+  typeof parseMarkdownLinkValidationData
+>;
+export function markdownLinkValidation(
+  options: MarkdownLinkValidationOptions
+): TypedCheckWithOptions<
+  string,
+  ResolvedMarkdownLinkValidationOptions,
+  typeof parseMarkdownLinkValidationData
+>;
+export function markdownLinkValidation(
+  options: MarkdownLinkValidationOptions = {}
+): TypedCheckWithOptions<
+  string,
+  ResolvedMarkdownLinkValidationOptions,
+  typeof parseMarkdownLinkValidationData
 > {
-  const resolvedOptions = resolveMarkdownLinkValidationOptions(options);
+  const input = resolvePackageCheckAuthoringInput(
+    options,
+    [
+      "files",
+      "findingPolicy",
+      "requireExistingTargets",
+      "validateSameDocumentAnchors",
+      "validateCrossDocumentAnchors",
+      "rootExternalTargetMode",
+      "requireNonEmptyDirectories",
+      "limits",
+      "cache"
+    ],
+    MARKDOWN_LINK_VALIDATION_CHECK_DEFINITION
+  );
+  if (input === undefined) {
+    throw new TypeError("markdownLinkValidation options must match the documented closed policy");
+  }
+  const resolvedOptions = resolveMarkdownLinkValidationOptions(input.domainOptions);
   if (resolvedOptions === undefined) {
     throw new TypeError("markdownLinkValidation options must match the documented closed policy");
   }
   return defineCheck({
-    ...MARKDOWN_LINK_VALIDATION_CHECK_DEFINITION,
-    execution: executeMarkdownLinkValidation,
+    ...input.definition,
+    execute: executeMarkdownLinkValidation,
     parseData: parseMarkdownLinkValidationData,
-    preflight: (preparedOptions) =>
+    prepare: (preparedOptions) =>
       validMarkdownLinkValidationOptions(preparedOptions)
         ? { status: "success", preparedOptions }
         : {

package/src/package-checks/markdown-link-validation/execution.ts

@@ -5,7 +5,7 @@ import type { CheckExecutionContext, CheckResult } from "../../check/check.ts";
 import { collectProjectFiles } from "../project-files/collection.ts";
 import type { ProjectFileSelection } from "../project-files/configuration.ts";
 import { partitionProjectFilesByEligibility } from "../project-files/input-eligibility.ts";
-import { appendCheckMessages } from "../../check/finding-presentation.ts";
+import { appendCheckMessages } from "../../package-tools/finding-presentation/finding-presentation.ts";
 import { createMarkdownLocalResolver, type MarkdownLocalResolver } from "./local-resolver.ts";
 import type { MarkdownLinkValidationFinalData } from "./final-data.ts";
 import { markdownFindingMessages } from "./finding-messages.ts";

package/src/package-checks/markdown-link-validation/finding-messages.ts

@@ -1,5 +1,5 @@
 import type { CheckMessage } from "../../check/check.ts";
-import { presentCheckFindings } from "../../check/finding-presentation.ts";
+import { presentCheckFindings } from "../../package-tools/finding-presentation/finding-presentation.ts";
 import type { MarkdownLinkRecordCandidate } from "./records.ts";
 
 const PRESENTED_FINDING_LIMIT = 10;

package/src/package-checks/markdown-link-validation/markdown-parser.ts

@@ -233,11 +233,7 @@ function isMarkdownAstNode(value: unknown): value is MarkdownAstNode {
 function sourceRangeFromPosition(
   position: MarkdownAstPosition | undefined
 ): MarkdownSourceRange | null {
-  if (
-    position === undefined ||
-    position.start.offset === undefined ||
-    position.end.offset === undefined
-  ) {
+  if (position?.start.offset === undefined || position?.end.offset === undefined) {
     return null;
   }
 

package/src/package-checks/markdown-link-validation/options-resolution.ts

@@ -1,6 +1,5 @@
 import { canonicalizeJsonObject } from "../../data-boundary/canonical-data.ts";
 import {
-  hasExactPlainRecordKeys,
   hasRequiredAndOptionalRecordKeys,
   snapshotClosedRecord
 } from "../../data-boundary/closed-values.ts";
@@ -10,6 +9,7 @@ import {
   snapshotProjectFileSelection
 } from "../project-files/configuration.ts";
 import { DEFAULT_FINDING_POLICY, resolveFindingPolicy } from "../code-quality-findings/policy.ts";
+import { resolveOptionalLocalCacheOptions } from "../local-cache-options.ts";
 import type { ResolvedMarkdownLinkValidationOptions } from "./options.ts";
 import { validMarkdownLinkValidationOptions } from "./options-validation.ts";
 
@@ -33,7 +33,7 @@ export function resolveMarkdownLinkValidationOptions(
   const limits = resolvedLimits(input.limits);
   const files = resolvedFiles(input.files);
   const findingPolicy = resolveFindingPolicy(input.findingPolicy, DEFAULT_FINDING_POLICY);
-  const cache = resolvedCache(input.cache);
+  const cache = resolveOptionalLocalCacheOptions(input.cache);
   if (
     limits === undefined ||
     files === undefined ||
@@ -94,23 +94,6 @@ function isMarkdownLinkValidationInput(
   );
 }
 
-function resolvedCache(value: unknown): ResolvedMarkdownLinkValidationOptions["cache"] | undefined {
-  if (value === undefined) return Object.freeze({ enabled: false as const });
-  const cache = snapshotClosedRecord(value);
-  if (cache === undefined) return undefined;
-  if (hasExactPlainRecordKeys(cache, ["enabled"]) && cache.enabled === false) {
-    return Object.freeze({ enabled: false as const });
-  }
-  if (
-    hasExactPlainRecordKeys(cache, ["enabled", "directory"]) &&
-    cache.enabled === true &&
-    typeof cache.directory === "string"
-  ) {
-    return Object.freeze({ enabled: true as const, directory: cache.directory });
-  }
-  return undefined;
-}
-
 function resolvedFiles(value: unknown) {
   return value === undefined
     ? snapshotProjectFileSelection(DEFAULT_FILES)

package/src/package-checks/markdown-link-validation/options-validation.ts

@@ -1,9 +1,8 @@
-import { isAbsolute } from "node:path";
-
 import { snapshotExactClosedRecord } from "../../data-boundary/closed-values.ts";
 import { isPositiveSafeInteger } from "../../data-boundary/value-shapes.ts";
 import { validProjectFileSelection } from "../project-files/configuration.ts";
 import { validFindingPolicy } from "../code-quality-findings/policy.ts";
+import { validLocalCacheOptions } from "../local-cache-options.ts";
 import type { ResolvedMarkdownLinkValidationOptions } from "./options.ts";
 
 function boundedPositiveSafeInteger(value: unknown, maximum: number): value is number {
@@ -32,25 +31,11 @@ function validOptionFields(options: Readonly<Record<string, unknown>>): boolean
     validProjectFileSelection(options.files) &&
     validFindingPolicy(options.findingPolicy) &&
     validAnchorValidationOptions(options) &&
-    validMarkdownLinkCache(options.cache) &&
+    validLocalCacheOptions(options.cache) &&
     validMarkdownLinkLimits(options.limits)
   );
 }
 
-function validMarkdownLinkCache(value: unknown): boolean {
-  const disabled = snapshotExactClosedRecord(value, ["enabled"]);
-  if (disabled !== undefined && disabled.enabled === false) return true;
-  const enabled = snapshotExactClosedRecord(value, ["enabled", "directory"]);
-  return (
-    enabled !== undefined &&
-    enabled.enabled === true &&
-    typeof enabled.directory === "string" &&
-    enabled.directory.length > 0 &&
-    !enabled.directory.includes("\0") &&
-    isAbsolute(enabled.directory)
-  );
-}
-
 function validAnchorValidationOptions(options: Readonly<Record<string, unknown>>): boolean {
   return (
     typeof options.requireExistingTargets === "boolean" &&

package/src/package-checks/markdown-link-validation/options.ts

@@ -1,18 +1,15 @@
+import type { PackageCheckAuthoringOptions } from "../check-authoring.ts";
 import type {
   ProjectFileSelection,
   ProjectFileSelectionOptions
 } from "../project-files/configuration.ts";
 import type { FindingPolicy } from "../code-quality-findings/policy.ts";
+import type { LocalCacheOptions } from "../local-cache-options.ts";
 
 export type MarkdownRootExternalTargetMode = "ignore" | "report" | "validate";
 
 /** 调用方显式拥有的 Link-private parse-facts local cache policy。 */
-type MarkdownLinkValidationCacheOptions =
-  | Readonly<{ readonly enabled: false }>
-  | Readonly<{
-      readonly enabled: true;
-      readonly directory: string;
-    }>;
+type MarkdownLinkValidationCacheOptions = LocalCacheOptions;
 
 /** 可省略的 Markdown validation work limits。 */
 export interface MarkdownLinkValidationLimitOptions {
@@ -22,7 +19,9 @@ export interface MarkdownLinkValidationLimitOptions {
 }
 
 /** `markdownLinkValidation(options?)` 接受的可省略 authoring policy。 */
-export interface MarkdownLinkValidationOptions {
+export interface MarkdownLinkValidationOptions<
+  Id extends string = string
+> extends PackageCheckAuthoringOptions<Id> {
   /** 参与本 Check 的 Markdown source selection；省略字段使用 package defaults。 */
   readonly files?: ProjectFileSelectionOptions;
   /** local-reference finding 是否使本 Check failed；省略时为 non-blocking。 */

package/src/package-checks/markdown-link-validation/parse-facts-cache-payload.ts

@@ -111,11 +111,10 @@ function isCurrentCacheEnvelope(
   readonly payload: unknown;
 }> {
   return (
-    envelope !== undefined &&
-    envelope.cacheFormatVersion === CACHE_FORMAT_VERSION &&
-    validIdentityDigest(envelope.identityDigest) &&
-    envelope.parserContractVersion === MARKDOWN_LINK_PARSE_FACTS_PARSER_CONTRACT_VERSION &&
-    envelope.payloadVersion === CACHE_PAYLOAD_VERSION
+    envelope?.cacheFormatVersion === CACHE_FORMAT_VERSION &&
+    validIdentityDigest(envelope?.identityDigest) &&
+    envelope?.parserContractVersion === MARKDOWN_LINK_PARSE_FACTS_PARSER_CONTRACT_VERSION &&
+    envelope?.payloadVersion === CACHE_PAYLOAD_VERSION
   );
 }