@zxyycom/vibe-check 0.0.2 → 0.0.3

package/src/package-checks/function-metrics/analyzer/readers/ttcn.ts

@@ -60,7 +60,9 @@ class TTCNStates extends CLikeStates {
       this.context.restartNewFunction("");
     } else if (token === "control") {
       this.context.restartNewFunction("__control__");
-      this.next((currentToken) => this._state_dec_to_imp(currentToken));
+      this.next((currentToken) => {
+        this._state_dec_to_imp(currentToken);
+      });
     }
   }
 
@@ -68,7 +70,9 @@ class TTCNStates extends CLikeStates {
     if (isAlphabetic(token)) {
       this.context.addToFunctionName(token);
     } else if (token === "(") {
-      this.next((currentToken) => this._state_dec(currentToken), token);
+      this.next((currentToken) => {
+        this._state_dec(currentToken);
+      }, token);
     } else if (token === "@deterministic") {
       this.context.addToLongFunctionName(`${token} `);
     } else {
@@ -78,7 +82,9 @@ class TTCNStates extends CLikeStates {
 
   protected override _state_dec_to_imp(token: string): void {
     if (token === "{") {
-      this.next((currentToken) => this._state_imp(currentToken), "{");
+      this.next((currentToken) => {
+        this._state_imp(currentToken);
+      }, "{");
     } else {
       this.context.addToLongFunctionName(` ${token}`);
     }

package/src/package-checks/function-metrics/analyzer/readers/typescript.ts

@@ -567,15 +567,21 @@ class TypeScriptTypeAnnotationStates extends CodeStateMachine {
   };
 
   private readonly _inline_type_annotation = (token: string): void => {
-    this.readInsideBracketsThen("{}", token, () => this.returnFromState());
+    this.readInsideBracketsThen("{}", token, () => {
+      this.returnFromState();
+    });
   };
 
   private readonly _state_generic_type = (token: string): void => {
-    this.readInsideBracketsThen("<>", token, () => this.returnFromState());
+    this.readInsideBracketsThen("<>", token, () => {
+      this.returnFromState();
+    });
   };
 
   private readonly _function_type_annotation = (token: string): void => {
-    this.readInsideBracketsThen("()", token, () => this.returnFromState());
+    this.readInsideBracketsThen("()", token, () => {
+      this.returnFromState();
+    });
   };
 }
 

package/src/package-checks/function-metrics/analyzer/readers/zig.ts

@@ -30,6 +30,7 @@ export class ZigReader extends CodeReader {
 class ZigStates extends GoLikeStates {
   protected static override readonly FUNC_KEYWORD = "fn";
 
-  protected override readonly _type_definition = (token: string): void =>
+  protected override readonly _type_definition = (token: string): void => {
     super._state_global(token);
+  };
 }

package/src/package-checks/function-metrics/analyzer/shared/code-reader.ts

@@ -110,7 +110,9 @@ export class CodeStateMachine {
   protected readUntilTokens: string[] = [];
   protected bracketCount = 0;
   protected readonly stateMachineConstructor: typeof CodeStateMachine;
-  protected readonly globalState: StateHandler = (token) => this._state_global(token);
+  protected readonly globalState: StateHandler = (token) => {
+    this._state_global(token);
+  };
 
   public constructor(context: FileInfoBuilder) {
     this.stateMachineConstructor = new.target;

package/src/package-checks/function-metrics/analyzer/shared/js-style-regex.ts

@@ -43,15 +43,20 @@ export function js_style_regex_expression(generator: TokenGenerator): TokenGener
         if (isRegex) {
           const regexTokens = [token];
           index += 1;
-          while (index < tokens.length && !tokens[index].endsWith("/")) {
-            regexTokens.push(tokens[index]);
+          while (index < tokens.length) {
+            const nextToken = tokens[index];
+            if (nextToken === undefined || nextToken.endsWith("/")) break;
+            regexTokens.push(nextToken);
             index += 1;
           }
           if (index < tokens.length) {
-            regexTokens.push(tokens[index]);
+            const closingToken = tokens[index];
+            if (closingToken === undefined) break;
+            regexTokens.push(closingToken);
             index += 1;
-            if (/^[igm]+$/u.test(tokens[index] ?? "")) {
-              regexTokens.push(tokens[index]);
+            const flags = tokens[index];
+            if (flags !== undefined && /^[igm]+$/u.test(flags)) {
+              regexTokens.push(flags);
               index += 1;
             }
           }

package/src/package-checks/function-metrics/analyzer-worker-port.ts

@@ -28,7 +28,9 @@ export interface FunctionMetricsWorkerPort {
 export function createNodeFunctionMetricsWorker(): FunctionMetricsWorkerPort {
   const worker = new Worker(new URL("./analyzer-worker.ts", import.meta.url));
   return Object.freeze({
-    postMessage: (value: unknown): void => worker.postMessage(value),
+    postMessage: (value: unknown): void => {
+      worker.postMessage(value);
+    },
     subscribe: (listeners: Parameters<FunctionMetricsWorkerPort["subscribe"]>[0]): (() => void) => {
       worker.once("message", listeners.message);
       worker.once("error", listeners.error);
@@ -69,17 +71,29 @@ export async function analyzeAdmittedSources(
       worker.terminate();
       resolveResult(result);
     };
-    const cancelled = (): void => finish(Object.freeze({ kind: "cancelled" }));
+    const cancelled = (): void => {
+      finish(Object.freeze({ kind: "cancelled" }));
+    };
     unsubscribe = worker.subscribe({
-      error: () => finish(Object.freeze({ kind: "analysis-failed" })),
-      exit: () => finish(Object.freeze({ kind: "analysis-failed" })),
+      error: () => {
+        finish(Object.freeze({ kind: "analysis-failed" }));
+      },
+      exit: () => {
+        finish(Object.freeze({ kind: "analysis-failed" }));
+      },
       message: (value: unknown): void => {
-        if (signal.aborted) return cancelled();
+        if (signal.aborted) {
+          cancelled();
+          return;
+        }
         finish(parseWorkerResponse(value, approvedExactPaths));
       }
     });
     signal.addEventListener("abort", cancelled, { once: true });
-    if (signal.aborted) return cancelled();
+    if (signal.aborted) {
+      cancelled();
+      return;
+    }
     try {
       worker.postMessage(request);
     } catch {

package/src/package-checks/function-metrics/constructor.ts

@@ -1,4 +1,8 @@
 import { defineCheck, type TypedCheckWithOptions } from "../../check/check.ts";
+import {
+  resolvePackageCheckAuthoringInput,
+  type PackageCheckIdentityInput
+} from "../check-authoring.ts";
 import { executeFunctionMetrics } from "./execution.ts";
 import { parseFunctionMetricsData } from "./final-data.ts";
 import type { FunctionMetricsOptions, ResolvedFunctionMetricsOptions } from "./options.ts";
@@ -14,27 +18,46 @@ const FUNCTION_METRICS_CHECK_DEFINITION = {
  * 使用可省略的区域、阈值与 finding policy 构造一个完整 function-metrics Check。
  *
  * @param options - 省略字段由 package 补齐；显式 files 数组完整替换对应字段的默认数组。
- * @returns 固定 `function-metrics` identity、完整冻结 options、preflight 与 execution。
+ * @returns 固定 `function-metrics` identity、完整冻结 options、preparation 与 execution。
  * @throws {TypeError} input 含未知字段、空 area、非法 finding policy/waiver 或非法 limit 时抛出。
  */
 export function functionMetrics(
-  options: FunctionMetricsOptions = {}
+  options?: FunctionMetricsOptions<"function-metrics">
 ): TypedCheckWithOptions<
   "function-metrics",
   ResolvedFunctionMetricsOptions,
   typeof parseFunctionMetricsData
-> {
-  const resolvedOptions = resolveFunctionMetricsOptions(options);
+>;
+export function functionMetrics<const Id extends string>(
+  options: FunctionMetricsOptions<Id> & PackageCheckIdentityInput<Id>
+): TypedCheckWithOptions<Id, ResolvedFunctionMetricsOptions, typeof parseFunctionMetricsData>;
+export function functionMetrics(
+  options: FunctionMetricsOptions
+): TypedCheckWithOptions<string, ResolvedFunctionMetricsOptions, typeof parseFunctionMetricsData>;
+export function functionMetrics(
+  options: FunctionMetricsOptions = {}
+): TypedCheckWithOptions<string, ResolvedFunctionMetricsOptions, typeof parseFunctionMetricsData> {
+  const input = resolvePackageCheckAuthoringInput(
+    options,
+    ["codeAreas", "findingPolicy", "findingWaivers"],
+    FUNCTION_METRICS_CHECK_DEFINITION
+  );
+  if (input === undefined) {
+    throw new TypeError(
+      "functionMetrics options must use the documented closed policy: a non-empty area map, recognized finding policies and waivers, and positive safe-integer limits"
+    );
+  }
+  const resolvedOptions = resolveFunctionMetricsOptions(input.domainOptions);
   if (resolvedOptions === undefined) {
     throw new TypeError(
       "functionMetrics options must use the documented closed policy: a non-empty area map, recognized finding policies and waivers, and positive safe-integer limits"
     );
   }
   return defineCheck({
-    ...FUNCTION_METRICS_CHECK_DEFINITION,
-    execution: executeFunctionMetrics,
+    ...input.definition,
+    execute: executeFunctionMetrics,
     parseData: parseFunctionMetricsData,
-    preflight: (preparedOptions) =>
+    prepare: (preparedOptions) =>
       validResolvedFunctionMetricsOptions(preparedOptions)
         ? { status: "success", preparedOptions }
         : {

package/src/package-checks/function-metrics/execution.ts

@@ -2,7 +2,7 @@ import type { CheckExecutionContext, CheckMessage, CheckResult } from "../../che
 import {
   reconcileFindingWaivers,
   type FindingWaiverReconciliation
-} from "../../finding-waivers/reconciliation.ts";
+} from "../../package-tools/finding-waivers/reconciliation.ts";
 import { collectProjectFileSets, requireProjectFileSet } from "../project-files/collection.ts";
 import { partitionProjectFilesByEligibility } from "../project-files/input-eligibility.ts";
 import { settleFindings } from "../code-quality-findings/policy.ts";
@@ -10,7 +10,7 @@ import {
   reportFindingWaiverAudits,
   reportReconciledCodeQualityFindingRecords
 } from "../code-quality-findings/finding-waiver-evidence.ts";
-import { appendCheckMessages } from "../../check/finding-presentation.ts";
+import { appendCheckMessages } from "../../package-tools/finding-presentation/finding-presentation.ts";
 import { functionFindingMessages, functionWaiverMessages } from "./finding-messages.ts";
 import { analyzeFunctionMetrics } from "./analysis.ts";
 import {
@@ -276,8 +276,6 @@ function directMeasurementFailure(
     case "source-unavailable":
       return unavailable("source-unavailable");
   }
-  const exhaustiveMeasurement: never = measurement;
-  return exhaustiveMeasurement;
 }
 
 function unavailable(

package/src/package-checks/function-metrics/finding-messages.ts

@@ -1,9 +1,9 @@
 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 {
   FindingWaiverAudit,
   FindingWaiverReconciliation
-} from "../../finding-waivers/reconciliation.ts";
+} from "../../package-tools/finding-waivers/reconciliation.ts";
 import {
   functionMetricsWaiverIdentity,
   type FunctionInputRejectedCandidate,

package/src/package-checks/function-metrics/measurement.ts

@@ -130,7 +130,9 @@ async function readBoundedSource(
 }
 
 function yieldAdmissionToTimer(): Promise<void> {
-  return new Promise<void>((resolveYield) => setTimeout(resolveYield, 0));
+  return new Promise<void>((resolveYield) => {
+    setTimeout(resolveYield, 0);
+  });
 }
 
 /**

package/src/package-checks/function-metrics/options.ts

@@ -1,9 +1,10 @@
+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 { FindingWaiver } from "../../finding-waivers/reconciliation.ts";
+import type { FindingWaiver } from "../../package-tools/finding-waivers/reconciliation.ts";
 
 /** `functionMetrics` 构造函数可省略的文件选择策略。 */
 export type FunctionMetricsFileOptions = ProjectFileSelectionOptions;
@@ -65,7 +66,9 @@ export interface FunctionMetricsFindingIdentity {
 export type FunctionMetricsFindingWaiver = FindingWaiver<FunctionMetricsFindingIdentity>;
 
 /** `functionMetrics(options?)` 接受并补齐默认值的公开策略。 */
-export interface FunctionMetricsOptions {
+export interface FunctionMetricsOptions<
+  Id extends string = string
+> extends PackageCheckAuthoringOptions<Id> {
   /** 省略时建立默认 `project` 区域；显式映射必须非空，且每个区域必须声明 `files`。 */
   readonly codeAreas?: Readonly<Record<string, FunctionMetricsCodeAreaOptions>>;
   /** 省略时为 `non-blocking`；区域可局部覆盖。 */
@@ -74,7 +77,7 @@ export interface FunctionMetricsOptions {
   readonly findingWaivers?: readonly FunctionMetricsFindingWaiver[];
 }
 
-/** 构造函数生成并由 Check preflight/execution 消费的完整 options。 */
+/** 构造函数生成并由 Check preparation/execution 消费的完整 options。 */
 export interface ResolvedFunctionMetricsOptions {
   readonly codeAreas: Readonly<Record<string, ResolvedFunctionMetricsCodeAreaOptions>>;
   readonly findingWaivers: readonly FunctionMetricsFindingWaiver[];

package/src/package-checks/function-metrics/records.ts

@@ -3,7 +3,7 @@ import {
   type FunctionMetricAnalysis,
   type FunctionMetricInstance
 } from "./analysis.ts";
-import type { MaterializedFindingWaiver } from "../../finding-waivers/reconciliation.ts";
+import type { MaterializedFindingWaiver } from "../../package-tools/finding-waivers/reconciliation.ts";
 import { isBlockingFinding } from "../code-quality-findings/policy.ts";
 import {
   buildHashedFindingWaiverAuditRecord,

package/src/package-checks/host-environment/git.ts

@@ -17,6 +17,17 @@ export function runGit(options: RunGitOptions): ProcessResult {
   return runProcessSync({ command: "git", ...options });
 }
 
+/** Renders the actionable failure evidence shared by Git operation boundaries. */
+export function gitFailureDetail(result: ProcessResult): string {
+  const stderr = result.stderr.trim();
+  if (stderr.length > 0) return stderr;
+  const processErrorMessage = result.error?.message;
+  if (processErrorMessage !== undefined && processErrorMessage.length > 0) {
+    return processErrorMessage;
+  }
+  return result.signal === null ? `exit status ${result.status}` : `signal ${result.signal}`;
+}
+
 export function gitHeadSha(cwd: string): string | null {
   const result = runGit({ args: ["rev-parse", "HEAD"], cwd });
   if (processFailed(result)) return null;

package/src/package-checks/host-environment/path.ts

@@ -1,20 +1 @@
-export function toSlashPath(filePath: string): string {
-  return filePath.replace(/\\/g, "/");
-}
-
-/** 判断值是否已是跨平台可稳定发布的 project-root-relative slash path。 */
-export function isNormalizedProjectRelativePath(value: unknown): value is string {
-  if (
-    typeof value !== "string" ||
-    value.length === 0 ||
-    value.startsWith("/") ||
-    value.includes("\\") ||
-    value.includes("\u0000") ||
-    /^[A-Za-z]:/u.test(value)
-  ) {
-    return false;
-  }
-  return value
-    .split("/")
-    .every((segment) => segment.length > 0 && segment !== "." && segment !== "..");
-}
+export { isNormalizedProjectRelativePath, toSlashPath } from "../../data-boundary/project-path.ts";

package/src/package-checks/host-environment/process/contract.ts

@@ -12,9 +12,12 @@ export interface ProcessFailure extends Error {
 
 export type ProcessResult = {
   readonly error?: Error;
+  readonly isCanceled?: true;
+  readonly isMaxBuffer?: true;
   readonly signal: NodeJS.Signals | null;
   readonly status: number | null;
   readonly stderr: string;
+  readonly timedOut?: true;
   readonly stdout: string;
 };
 
@@ -32,8 +35,11 @@ export type RunProcessSyncOptions = {
 
 export type RunProcessOptions = {
   readonly args?: readonly string[];
+  readonly cancelSignal?: AbortSignal;
   readonly command: string;
   readonly cwd?: string | URL;
+  /** `false` uses only the supplied `env`; omission preserves Execa's inherited default. */
+  readonly extendEnv?: boolean;
   readonly env?: NodeJS.ProcessEnv;
   readonly label?: string;
   readonly maxBuffer?: number;
@@ -42,15 +48,17 @@ export type RunProcessOptions = {
 };
 
 export type ExecaResultLike = {
-  readonly code?: string;
-  readonly exitCode?: number;
-  readonly failed?: boolean;
-  readonly isMaxBuffer?: boolean;
-  readonly message?: string;
-  readonly originalMessage?: string;
-  readonly shortMessage?: string;
-  readonly signal?: NodeJS.Signals;
+  /** Execa's imported result types permit explicitly present `undefined` values. */
+  readonly code?: string | undefined;
+  readonly exitCode?: number | undefined;
+  readonly failed?: boolean | undefined;
+  readonly isCanceled?: boolean | undefined;
+  readonly isMaxBuffer?: boolean | undefined;
+  readonly message?: string | undefined;
+  readonly originalMessage?: string | undefined;
+  readonly shortMessage?: string | undefined;
+  readonly signal?: NodeJS.Signals | undefined;
   readonly stderr?: unknown;
   readonly stdout?: unknown;
-  readonly timedOut?: boolean;
+  readonly timedOut?: boolean | undefined;
 };

package/src/package-checks/host-environment/process/result.ts

@@ -1,11 +1,16 @@
 import type { ExecaResultLike, ProcessResult } from "./contract.ts";
 
 export function toProcessResult(result: ExecaResultLike, label: string): ProcessResult {
+  const cause = processCause(result);
+  const error = processErrorFor(result, label, cause);
   return {
-    error: processErrorFor(result, label),
+    ...(error === undefined ? {} : { error }),
+    ...(cause === "cancellation" ? { isCanceled: true as const } : {}),
+    ...(cause === "max-buffer" ? { isMaxBuffer: true as const } : {}),
     signal: result.signal ?? null,
     status: result.exitCode ?? null,
     stderr: outputString(result.stderr),
+    ...(cause === "timeout" ? { timedOut: true as const } : {}),
     stdout: outputString(result.stdout)
   };
 }
@@ -14,26 +19,49 @@ function outputString(output: unknown): string {
   return typeof output === "string" ? output : "";
 }
 
-function processErrorFor(result: ExecaResultLike, label = "process"): Error | undefined {
-  if (!isExecutionError(result)) {
-    return undefined;
-  }
-
-  const message =
-    result.originalMessage ?? result.shortMessage ?? result.message ?? `${label} failed`;
-  const error: NodeJS.ErrnoException = new Error(message);
-  if (result.code) {
-    error.code = result.code;
-  }
+type ProcessCause =
+  | "cancellation"
+  | "exit"
+  | "max-buffer"
+  | "signal"
+  | "startup-failure"
+  | "timeout";
+
+function processCause(result: ExecaResultLike): ProcessCause {
+  if (typeof result.exitCode === "number" && result.exitCode !== 0) return "exit";
+  if (result.isCanceled === true) return "cancellation";
+  if (result.timedOut === true) return "timeout";
+  if (result.isMaxBuffer === true) return "max-buffer";
+  if (result.signal !== undefined) return "signal";
+  if (result.exitCode === 0) return "exit";
+  return "startup-failure";
+}
+
+function processErrorFor(
+  result: ExecaResultLike,
+  label: string,
+  cause: ProcessCause
+): Error | undefined {
+  if (!requiresProcessError(cause, result)) return undefined;
+
+  const error: NodeJS.ErrnoException = new Error(processErrorMessage(result, label));
+  const code = processErrorCode(result);
+  if (code !== undefined) error.code = code;
   return error;
 }
 
-function isExecutionError(result: ExecaResultLike): boolean {
-  if (!result.failed) {
-    return false;
-  }
-  if (typeof result.exitCode === "number") {
-    return false;
-  }
-  return Boolean(result.code || result.timedOut || result.isMaxBuffer || result.signal);
+function requiresProcessError(cause: ProcessCause, result: ExecaResultLike): boolean {
+  return cause !== "exit" && result.failed === true;
+}
+
+function processErrorMessage(result: ExecaResultLike, label: string): string {
+  if (result.originalMessage !== undefined) return result.originalMessage;
+  if (result.shortMessage !== undefined) return result.shortMessage;
+  if (result.message !== undefined) return result.message;
+  return `${label} failed`;
+}
+
+function processErrorCode(result: ExecaResultLike): string | undefined {
+  if (result.code === undefined || result.code.length === 0) return undefined;
+  return result.code;
 }

package/src/package-checks/host-environment/process/runner.ts

@@ -14,7 +14,7 @@ export function runProcessSync(options: RunProcessSyncOptions): ProcessResult {
   const result = execaSync(command, args, {
     ...processOptions,
     encoding: processOptions.encoding ?? "utf8",
-    env: plainTextProcessEnv({ env: processOptions.env }),
+    env: plainTextProcessEnv(processOptions.env === undefined ? {} : { env: processOptions.env }),
     maxBuffer: processOptions.maxBuffer ?? DEFAULT_PROCESS_MAX_BUFFER_BYTES,
     reject: false,
     stripFinalNewline: false,
@@ -26,9 +26,11 @@ export function runProcessSync(options: RunProcessSyncOptions): ProcessResult {
 export function runProcess(options: RunProcessOptions): Promise<ProcessResult> {
   const {
     args = [],
+    cancelSignal,
     command,
     cwd,
     env,
+    extendEnv,
     label = command,
     maxBuffer = DEFAULT_PROCESS_MAX_BUFFER_BYTES,
     timeout,
@@ -36,12 +38,14 @@ export function runProcess(options: RunProcessOptions): Promise<ProcessResult> {
   } = options;
 
   return execa(command, args, {
-    cwd,
-    env: plainTextProcessEnv({ env }),
+    ...(cancelSignal === undefined ? {} : { cancelSignal }),
+    ...(cwd === undefined ? {} : { cwd }),
+    ...(extendEnv === undefined ? {} : { extendEnv }),
+    env: plainTextProcessEnv(env === undefined ? {} : { env }),
     maxBuffer,
     reject: false,
     stripFinalNewline: false,
-    timeout,
+    ...(timeout === undefined ? {} : { timeout }),
     windowsHide
   }).then((result) => toProcessResult(result, label));
 }

package/src/package-checks/json-schema-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_SCHEMA_VALIDATION_CHECK_DEFINITION,
   executeJsonSchemaValidation
@@ -19,21 +23,50 @@ import { validJsonSchemaValidationOptions } from "./options-validation.ts";
  * @throws {TypeError} input 不符合 closed authoring policy、identity 或 binding 不变量时抛出。
  */
 export function jsonSchemaValidation(
-  options: JsonSchemaValidationOptions = {}
+  options?: JsonSchemaValidationOptions<"json-schema-validation">
 ): TypedCheckWithOptions<
   "json-schema-validation",
   ResolvedJsonSchemaValidationOptions,
   typeof parseJsonSchemaValidationData
+>;
+export function jsonSchemaValidation<const Id extends string>(
+  options: JsonSchemaValidationOptions<Id> & PackageCheckIdentityInput<Id>
+): TypedCheckWithOptions<
+  Id,
+  ResolvedJsonSchemaValidationOptions,
+  typeof parseJsonSchemaValidationData
+>;
+export function jsonSchemaValidation(
+  options: JsonSchemaValidationOptions
+): TypedCheckWithOptions<
+  string,
+  ResolvedJsonSchemaValidationOptions,
+  typeof parseJsonSchemaValidationData
+>;
+export function jsonSchemaValidation(
+  options: JsonSchemaValidationOptions = {}
+): TypedCheckWithOptions<
+  string,
+  ResolvedJsonSchemaValidationOptions,
+  typeof parseJsonSchemaValidationData
 > {
-  const resolvedOptions = resolveJsonSchemaValidationOptions(options);
+  const input = resolvePackageCheckAuthoringInput(
+    options,
+    ["files", "maximumBytes", "schemaIdentity", "referenceResolution", "schemas", "bindings"],
+    JSON_SCHEMA_VALIDATION_CHECK_DEFINITION
+  );
+  if (input === undefined) {
+    throw new TypeError("jsonSchemaValidation options must match the documented closed policy");
+  }
+  const resolvedOptions = resolveJsonSchemaValidationOptions(input.domainOptions);
   if (resolvedOptions === undefined) {
     throw new TypeError("jsonSchemaValidation options must match the documented closed policy");
   }
   return defineCheck({
-    ...JSON_SCHEMA_VALIDATION_CHECK_DEFINITION,
-    execution: executeJsonSchemaValidation,
+    ...input.definition,
+    execute: executeJsonSchemaValidation,
     parseData: parseJsonSchemaValidationData,
-    preflight: (preparedOptions) =>
+    prepare: (preparedOptions) =>
       validJsonSchemaValidationOptions(preparedOptions)
         ? { status: "success", preparedOptions }
         : {

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

@@ -1,3 +1,4 @@
+import type { PackageCheckAuthoringOptions } from "../check-authoring.ts";
 import type {
   ProjectFileSelection,
   ProjectFileSelectionOptions
@@ -63,7 +64,9 @@ export interface JsonSchemaInstanceBinding {
 }
 
 /** `jsonSchemaValidation(options?)` 接受的可省略 authoring policy。 */
-export interface JsonSchemaValidationOptions {
+export interface JsonSchemaValidationOptions<
+  Id extends string = string
+> extends PackageCheckAuthoringOptions<Id> {
   /** schema/instance declarations 必须属于的 repository-file selection。 */
   readonly files?: ProjectFileSelectionOptions;
   /** 每个 local schema/instance document 允许的最大 raw byte 数；省略时为 1 MiB。 */

package/src/package-checks/json-schema-validation/reference-resolver.ts

@@ -68,9 +68,13 @@ export class ControlledReferenceResolver {
       throw new ReferenceResolutionFailure("unapproved-reference");
     if (this.#resolverInput.signal.aborted) throw new ReferenceTransportFailure();
     const controller = new AbortController();
-    const abortForCaller = (): void => controller.abort();
+    const abortForCaller = (): void => {
+      controller.abort();
+    };
     this.#resolverInput.signal.addEventListener("abort", abortForCaller, { once: true });
-    const timeout = setTimeout(() => controller.abort(), REMOTE_TIMEOUT_MS);
+    const timeout = setTimeout(() => {
+      controller.abort();
+    }, REMOTE_TIMEOUT_MS);
     try {
       return await this.loadWithController(referenceUri, controller);
     } catch (error) {