@zxyycom/vibe-check 0.0.1

package/src/package-checks/json-schema-validation/execution-stages.ts

@@ -0,0 +1,230 @@
+import { resolve } from "node:path";
+
+import type { CheckExecutionContext } from "../../check/check.ts";
+import { readStrictJsonDocument } from "../json-document/strict-document.ts";
+import {
+  normalizeValidationErrors,
+  type CompiledSchemaSet,
+  type LoadedSchema
+} from "./schema-engine.ts";
+import type { SchemaIssueCollector } from "./issue-collector.ts";
+import type {
+  JsonSchemaValidationRecordData,
+  JsonSchemaValidationUnavailableCode
+} from "./json-schema-validation.ts";
+import type { ResolvedJsonSchemaValidationOptions } from "./options.ts";
+
+type UnavailableStage = Readonly<{
+  readonly code: JsonSchemaValidationUnavailableCode;
+  readonly kind: "unavailable";
+}>;
+
+type Stage<T> = Readonly<{ readonly kind: "complete"; readonly value: T }> | UnavailableStage;
+
+export interface LoadedSchemaStage {
+  readonly failures: ReadonlySet<string>;
+  readonly schemas: readonly LoadedSchema[];
+}
+
+export interface BindingCounts {
+  readonly blockedBindingCount: number;
+  readonly invalidBindingCount: number;
+  readonly validBindingCount: number;
+}
+
+type SchemaContext = CheckExecutionContext<ResolvedJsonSchemaValidationOptions>;
+
+export async function loadConfiguredSchemas(
+  context: SchemaContext,
+  selectedPaths: ReadonlySet<string>,
+  issueCollector: SchemaIssueCollector
+): Promise<Stage<LoadedSchemaStage>> {
+  const failures = new Set<string>();
+  const schemas: LoadedSchema[] = [];
+  for (const schema of context.options.schemas) {
+    const outcome = loadConfiguredSchema(context, selectedPaths, schema, issueCollector);
+    if (outcome.kind === "unavailable") return outcome;
+    if (outcome.kind === "failure") failures.add(schema.id);
+    else schemas.push(outcome.value);
+  }
+  return complete({ failures, schemas });
+}
+
+type SchemaLoadOutcome =
+  | Readonly<{ readonly kind: "failure" }>
+  | Readonly<{ readonly kind: "loaded"; readonly value: LoadedSchema }>
+  | Readonly<{ readonly code: JsonSchemaValidationUnavailableCode; readonly kind: "unavailable" }>;
+
+function loadConfiguredSchema(
+  context: SchemaContext,
+  selectedPaths: ReadonlySet<string>,
+  schema: ResolvedJsonSchemaValidationOptions["schemas"][number],
+  issueCollector: SchemaIssueCollector
+): SchemaLoadOutcome {
+  if (context.signal.aborted) return unavailable("execution-cancelled");
+  if (!selectedPaths.has(schema.path)) {
+    issueCollector.add(schemaDocumentIssue(schema, "out-of-scope"));
+    return { kind: "failure" };
+  }
+  const document = readStrictJsonDocument({
+    filePath: resolve(context.project.root, schema.path),
+    maximumBytes: context.options.maximumBytes
+  });
+  if (context.signal.aborted) return unavailable("execution-cancelled");
+  if (document.kind === "unavailable") return unavailable("document-unavailable");
+  if (document.kind === "issue") {
+    issueCollector.add(schemaDocumentIssue(schema, document.reason));
+    return { kind: "failure" };
+  }
+  return {
+    kind: "loaded",
+    value: Object.freeze({ documentValue: document.jsonValue, id: schema.id })
+  };
+}
+
+function schemaDocumentIssue(
+  schema: ResolvedJsonSchemaValidationOptions["schemas"][number],
+  reason: Extract<JsonSchemaValidationRecordData, { readonly kind: "schema-document" }>["reason"]
+): Extract<JsonSchemaValidationRecordData, { readonly kind: "schema-document" }> {
+  return Object.freeze({ kind: "schema-document", path: schema.path, reason, schemaId: schema.id });
+}
+
+export function reportCompilationFailures(
+  context: SchemaContext,
+  compiled: CompiledSchemaSet,
+  failures: Set<string>,
+  issueCollector: SchemaIssueCollector
+): void {
+  for (const schema of context.options.schemas) {
+    const reason = compiled.failures.get(schema.id);
+    if (reason === undefined) continue;
+    failures.add(schema.id);
+    issueCollector.add(
+      Object.freeze({ kind: "schema-compile", path: schema.path, reason, schemaId: schema.id })
+    );
+  }
+}
+
+export async function validateSchemaBindings(
+  context: SchemaContext,
+  selectedPaths: ReadonlySet<string>,
+  compiled: CompiledSchemaSet,
+  schemaFailures: ReadonlySet<string>,
+  issueCollector: SchemaIssueCollector
+): Promise<Stage<BindingCounts>> {
+  const counts = { blockedBindingCount: 0, invalidBindingCount: 0, validBindingCount: 0 };
+  for (const binding of context.options.bindings) {
+    const outcome = validateSchemaBinding({
+      binding,
+      compiled,
+      context,
+      issueCollector,
+      schemaFailures,
+      selectedPaths
+    });
+    if (outcome.kind === "unavailable") return outcome;
+    counts[outcome.kind] += 1;
+  }
+  return complete(counts);
+}
+
+type BindingOutcome =
+  | Readonly<{ readonly kind: "blockedBindingCount" | "invalidBindingCount" | "validBindingCount" }>
+  | Readonly<{ readonly code: JsonSchemaValidationUnavailableCode; readonly kind: "unavailable" }>;
+
+interface BindingValidationInput {
+  readonly binding: ResolvedJsonSchemaValidationOptions["bindings"][number];
+  readonly compiled: CompiledSchemaSet;
+  readonly context: SchemaContext;
+  readonly issueCollector: SchemaIssueCollector;
+  readonly schemaFailures: ReadonlySet<string>;
+  readonly selectedPaths: ReadonlySet<string>;
+}
+
+function validateSchemaBinding(input: Readonly<BindingValidationInput>): BindingOutcome {
+  const { binding, compiled, context, issueCollector, schemaFailures, selectedPaths } = input;
+  if (context.signal.aborted) return unavailable("execution-cancelled");
+  const inScope = selectedPaths.has(binding.instancePath);
+  if (!inScope) issueCollector.add(instanceDocumentIssue(binding, "out-of-scope"));
+  if (schemaFailures.has(binding.schemaId)) return { kind: "blockedBindingCount" };
+  if (!inScope) return { kind: "invalidBindingCount" };
+  return validateBoundDocument(context, compiled, binding, issueCollector);
+}
+
+function validateBoundDocument(
+  context: SchemaContext,
+  compiled: CompiledSchemaSet,
+  binding: ResolvedJsonSchemaValidationOptions["bindings"][number],
+  issueCollector: SchemaIssueCollector
+): BindingOutcome {
+  const document = readStrictJsonDocument({
+    filePath: resolve(context.project.root, binding.instancePath),
+    maximumBytes: context.options.maximumBytes
+  });
+  if (context.signal.aborted) return unavailable("execution-cancelled");
+  if (document.kind === "unavailable") return unavailable("document-unavailable");
+  if (document.kind === "issue") {
+    issueCollector.add(instanceDocumentIssue(binding, document.reason));
+    return { kind: "invalidBindingCount" };
+  }
+  return validateDocumentValue(compiled, binding, document.jsonValue, issueCollector);
+}
+
+function validateDocumentValue(
+  compiled: CompiledSchemaSet,
+  binding: ResolvedJsonSchemaValidationOptions["bindings"][number],
+  value: LoadedSchema["documentValue"],
+  issueCollector: SchemaIssueCollector
+): BindingOutcome {
+  const validator = compiled.validators.get(binding.schemaId);
+  if (validator === undefined) return unavailable("engine-unavailable");
+  try {
+    if (validator(value)) return { kind: "validBindingCount" };
+  } catch {
+    return unavailable("engine-unavailable");
+  }
+  reportKeywordViolations(binding, normalizeValidationErrors(validator.errors), issueCollector);
+  return { kind: "invalidBindingCount" };
+}
+
+function instanceDocumentIssue(
+  binding: ResolvedJsonSchemaValidationOptions["bindings"][number],
+  reason: Extract<JsonSchemaValidationRecordData, { readonly kind: "instance-document" }>["reason"]
+): Extract<JsonSchemaValidationRecordData, { readonly kind: "instance-document" }> {
+  return Object.freeze({
+    bindingId: binding.id,
+    kind: "instance-document",
+    path: binding.instancePath,
+    reason,
+    schemaId: binding.schemaId
+  });
+}
+
+function reportKeywordViolations(
+  binding: ResolvedJsonSchemaValidationOptions["bindings"][number],
+  violations: ReturnType<typeof normalizeValidationErrors>,
+  issueCollector: SchemaIssueCollector
+): void {
+  const reported =
+    violations.length === 0 ? [Object.freeze({ keyword: "other", pointer: "" })] : violations;
+  for (const violation of reported) {
+    issueCollector.add(
+      Object.freeze({
+        bindingId: binding.id,
+        keyword: violation.keyword,
+        kind: "keyword-violation",
+        path: binding.instancePath,
+        pointer: violation.pointer,
+        schemaId: binding.schemaId
+      })
+    );
+  }
+}
+
+function complete<T>(value: T): Stage<T> {
+  return Object.freeze({ kind: "complete", value });
+}
+
+function unavailable(code: JsonSchemaValidationUnavailableCode): UnavailableStage {
+  return Object.freeze({ code, kind: "unavailable" });
+}

package/src/package-checks/json-schema-validation/final-data.ts

@@ -0,0 +1,115 @@
+import {
+  exactFinalDataRecord,
+  invalidFinalData,
+  nonNegativeSafeInteger
+} from "../final-data-parsing.ts";
+
+/** 单次运行最多发布的 JSON Schema issue Record 数量。 */
+export const MAX_REPORTED_JSON_SCHEMA_ISSUES = 100;
+
+/** `json-schema-validation` 在 passed/failed outcome 中发布的主数据。 */
+export interface JsonSchemaValidationFinalData {
+  readonly bindingCount: number;
+  readonly blockedBindingCount: number;
+  readonly invalidBindingCount: number;
+  readonly issueCount: number;
+  readonly issuesTruncated: boolean;
+  readonly reportedIssueCount: number;
+  readonly schemaCount: number;
+  readonly validBindingCount: number;
+}
+
+/** 验证计数与截断不变量并脱离 canonical final data。 */
+export function parseJsonSchemaValidationData(data: unknown): JsonSchemaValidationFinalData {
+  const value = jsonSchemaFinalDataRecord(data);
+  const counts = parsedCounts(value);
+  const issuesTruncated = value.issuesTruncated;
+  if (typeof issuesTruncated !== "boolean" || !validFinalDataInvariants(issuesTruncated, counts)) {
+    throw invalidFinalData("jsonSchemaValidation");
+  }
+  return Object.freeze({
+    bindingCount: counts.bindingCount,
+    blockedBindingCount: counts.blockedBindingCount,
+    invalidBindingCount: counts.invalidBindingCount,
+    issueCount: counts.issueCount,
+    issuesTruncated,
+    reportedIssueCount: counts.reportedIssueCount,
+    schemaCount: counts.schemaCount,
+    validBindingCount: counts.validBindingCount
+  });
+}
+
+function jsonSchemaFinalDataRecord(data: unknown): Readonly<Record<string, unknown>> {
+  return exactFinalDataRecord(
+    data,
+    [
+      "bindingCount",
+      "blockedBindingCount",
+      "invalidBindingCount",
+      "issueCount",
+      "issuesTruncated",
+      "reportedIssueCount",
+      "schemaCount",
+      "validBindingCount"
+    ],
+    "jsonSchemaValidation"
+  );
+}
+
+interface ParsedCounts {
+  readonly bindingCount: number | undefined;
+  readonly blockedBindingCount: number | undefined;
+  readonly invalidBindingCount: number | undefined;
+  readonly issueCount: number | undefined;
+  readonly reportedIssueCount: number | undefined;
+  readonly schemaCount: number | undefined;
+  readonly validBindingCount: number | undefined;
+}
+
+function parsedCounts(value: Readonly<Record<string, unknown>>): ParsedCounts {
+  return {
+    bindingCount: nonNegativeSafeInteger(value.bindingCount),
+    blockedBindingCount: nonNegativeSafeInteger(value.blockedBindingCount),
+    invalidBindingCount: nonNegativeSafeInteger(value.invalidBindingCount),
+    issueCount: nonNegativeSafeInteger(value.issueCount),
+    reportedIssueCount: nonNegativeSafeInteger(value.reportedIssueCount),
+    schemaCount: nonNegativeSafeInteger(value.schemaCount),
+    validBindingCount: nonNegativeSafeInteger(value.validBindingCount)
+  };
+}
+
+interface CompleteCounts {
+  readonly bindingCount: number;
+  readonly blockedBindingCount: number;
+  readonly invalidBindingCount: number;
+  readonly issueCount: number;
+  readonly reportedIssueCount: number;
+  readonly schemaCount: number;
+  readonly validBindingCount: number;
+}
+
+function validFinalDataInvariants(
+  issuesTruncated: boolean,
+  counts: ParsedCounts
+): counts is CompleteCounts {
+  if (!allCountsDefined(counts)) return false;
+  return (
+    counts.bindingCount ===
+      counts.blockedBindingCount + counts.invalidBindingCount + counts.validBindingCount &&
+    counts.reportedIssueCount <= counts.issueCount &&
+    counts.reportedIssueCount <= MAX_REPORTED_JSON_SCHEMA_ISSUES &&
+    issuesTruncated === counts.issueCount > counts.reportedIssueCount
+  );
+}
+
+function allCountsDefined(counts: ParsedCounts): counts is CompleteCounts {
+  return (
+    counts.bindingCount !== undefined &&
+    counts.blockedBindingCount !== undefined &&
+    counts.invalidBindingCount !== undefined &&
+    counts.issueCount !== undefined &&
+    counts.reportedIssueCount !== undefined &&
+    counts.schemaCount !== undefined &&
+    counts.validBindingCount !== undefined
+  );
+}

package/src/package-checks/json-schema-validation/issue-collector.ts

@@ -0,0 +1,43 @@
+import { createHash } from "node:crypto";
+
+import type { CheckExecutionContext } from "../../check/check.ts";
+import { MAX_REPORTED_JSON_SCHEMA_ISSUES } from "./final-data.ts";
+import type { JsonSchemaValidationRecordData } from "./json-schema-validation.ts";
+import type { ResolvedJsonSchemaValidationOptions } from "./options.ts";
+
+/** Owns the invocation-local issue count, display cap, and deterministic Record identity ordinal. */
+export class SchemaIssueCollector {
+  #count = 0;
+  #reportedCount = 0;
+  readonly #issueOccurrences = new Map<string, number>();
+  readonly #checkContext: CheckExecutionContext<ResolvedJsonSchemaValidationOptions>;
+
+  constructor(context: CheckExecutionContext<ResolvedJsonSchemaValidationOptions>) {
+    this.#checkContext = context;
+  }
+
+  get count(): number {
+    return this.#count;
+  }
+
+  get reportedCount(): number {
+    return this.#reportedCount;
+  }
+
+  get truncated(): boolean {
+    return this.#count > this.#reportedCount;
+  }
+
+  add(issue: JsonSchemaValidationRecordData): void {
+    this.#count += 1;
+    if (this.#reportedCount >= MAX_REPORTED_JSON_SCHEMA_ISSUES) return;
+    const semanticKey = JSON.stringify(issue);
+    const occurrence = this.#issueOccurrences.get(semanticKey) ?? 0;
+    this.#issueOccurrences.set(semanticKey, occurrence + 1);
+    const digest = createHash("sha256")
+      .update(`${semanticKey}\n${occurrence}`, "utf8")
+      .digest("hex");
+    this.#checkContext.records.report({ id: `json-schema:${issue.kind}:${digest}` }, issue);
+    this.#reportedCount += 1;
+  }
+}

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

@@ -0,0 +1,191 @@
+import type { CheckExecutionContext, CheckResult } from "../../check/check.ts";
+import { collectProjectFiles } from "../project-files/collection.ts";
+import type { JsonDocumentIssue } from "../json-document/strict-document.ts";
+import { compileSchemaSet, type SchemaCompileReason } from "./schema-engine.ts";
+import {
+  loadConfiguredSchemas,
+  reportCompilationFailures,
+  validateSchemaBindings
+} from "./execution-stages.ts";
+import { type JsonSchemaValidationFinalData } from "./final-data.ts";
+import { SchemaIssueCollector } from "./issue-collector.ts";
+import type { ResolvedJsonSchemaValidationOptions } from "./options.ts";
+import { validJsonSchemaValidationOptions } from "./options-validation.ts";
+
+export const JSON_SCHEMA_VALIDATION_CHECK_DEFINITION = {
+  checkId: "json-schema-validation",
+  displayName: "JSON Schema validation"
+} as const;
+
+/** `json-schema-validation` whole-Check unavailable outcome 的稳定 reason code。 */
+export type JsonSchemaValidationUnavailableCode =
+  | "invalid-options"
+  | "engine-unavailable"
+  | "execution-cancelled"
+  | "reference-transport-unavailable"
+  | "scan-input-unavailable"
+  | "document-unavailable";
+
+/** Schema 或 instance document Record 的稳定 document reason。 */
+export type JsonSchemaDocumentReason = JsonDocumentIssue | "out-of-scope";
+
+/** Schema/document Record 中带 `reason` branch 的稳定问题原因。 */
+export type JsonSchemaValidationRecordReason = JsonSchemaDocumentReason | SchemaCompileReason;
+
+/** 一条 schema document、compile、instance 或 keyword issue Record 的 data。 */
+export type JsonSchemaValidationRecordData =
+  | Readonly<{
+      readonly kind: "schema-document";
+      readonly path: string;
+      readonly reason: JsonSchemaDocumentReason;
+      readonly schemaId: string;
+    }>
+  | Readonly<{
+      readonly kind: "schema-compile";
+      readonly path: string;
+      readonly reason: SchemaCompileReason;
+      readonly schemaId: string;
+    }>
+  | Readonly<{
+      readonly bindingId: string;
+      readonly kind: "instance-document";
+      readonly path: string;
+      readonly reason: JsonSchemaDocumentReason;
+      readonly schemaId: string;
+    }>
+  | Readonly<{
+      readonly bindingId: string;
+      readonly keyword: string;
+      readonly kind: "keyword-violation";
+      readonly path: string;
+      readonly pointer: string;
+      readonly schemaId: string;
+    }>;
+
+/** Validates only explicitly registered/bound JSON files inside the current global scan scope. */
+export async function executeJsonSchemaValidation(
+  context: CheckExecutionContext<ResolvedJsonSchemaValidationOptions>
+): Promise<CheckResult<JsonSchemaValidationFinalData>> {
+  if (!validJsonSchemaValidationOptions(context.options)) return unavailable("invalid-options");
+
+  try {
+    return await execute(context);
+  } catch {
+    return unavailable("engine-unavailable");
+  }
+}
+
+async function execute(
+  context: CheckExecutionContext<ResolvedJsonSchemaValidationOptions>
+): Promise<CheckResult<JsonSchemaValidationFinalData>> {
+  if (context.signal.aborted) return unavailable("execution-cancelled");
+  if (context.options.bindings.length === 0) return noBindingsResult();
+  const selectedPaths = selectedProjectPaths(context);
+  if (selectedPaths === undefined) return unavailable("scan-input-unavailable");
+  if (context.signal.aborted) return unavailable("execution-cancelled");
+
+  const issueCollector = new SchemaIssueCollector(context);
+  const loaded = await loadConfiguredSchemas(context, selectedPaths, issueCollector);
+  if (loaded.kind === "unavailable") return unavailable(loaded.code);
+  const compilation = await compileSchemaSet({
+    referenceResolution: context.options.referenceResolution,
+    schemaIdentity: context.options.schemaIdentity,
+    schemas: loaded.value.schemas,
+    signal: context.signal
+  });
+  if (compilation.kind === "unavailable") return unavailable(compilation.reason);
+  if (context.signal.aborted) return unavailable("execution-cancelled");
+
+  const schemaFailures = new Set(loaded.value.failures);
+  reportCompilationFailures(context, compilation.compiledSchemaSet, schemaFailures, issueCollector);
+  const bindings = await validateSchemaBindings(
+    context,
+    selectedPaths,
+    compilation.compiledSchemaSet,
+    schemaFailures,
+    issueCollector
+  );
+  if (bindings.kind === "unavailable") return unavailable(bindings.code);
+  return completedValidationResult(context, bindings.value, issueCollector);
+}
+
+function selectedProjectPaths(
+  context: CheckExecutionContext<ResolvedJsonSchemaValidationOptions>
+): ReadonlySet<string> | undefined {
+  try {
+    return new Set(collectProjectFiles(context.project.root, context.options.files));
+  } catch {
+    return undefined;
+  }
+}
+
+function noBindingsResult(): CheckResult<JsonSchemaValidationFinalData> {
+  return Object.freeze({ status: "not-applicable", reason: { code: "no-bindings" } });
+}
+
+function completedValidationResult(
+  context: CheckExecutionContext<ResolvedJsonSchemaValidationOptions>,
+  bindings: Readonly<{
+    readonly blockedBindingCount: number;
+    readonly invalidBindingCount: number;
+    readonly validBindingCount: number;
+  }>,
+  issueCollector: SchemaIssueCollector
+): CheckResult<JsonSchemaValidationFinalData> {
+  const data = Object.freeze({
+    bindingCount: context.options.bindings.length,
+    blockedBindingCount: bindings.blockedBindingCount,
+    invalidBindingCount: bindings.invalidBindingCount,
+    issueCount: issueCollector.count,
+    issuesTruncated: issueCollector.truncated,
+    reportedIssueCount: issueCollector.reportedCount,
+    schemaCount: context.options.schemas.length,
+    validBindingCount: bindings.validBindingCount
+  });
+  if (issueCollector.count === 0) return Object.freeze({ data, status: "passed" });
+  return Object.freeze({
+    data,
+    messages: Object.freeze([
+      Object.freeze({
+        code: "schema-validation-issues",
+        level: "error" as const,
+        message: validationIssueMessage(issueCollector)
+      })
+    ]),
+    status: "failed"
+  });
+}
+
+function validationIssueMessage(issueCollector: SchemaIssueCollector): string {
+  const truncation = issueCollector.truncated ? " (the published Record list is truncated)" : "";
+  return `${issueCollector.count} schema validation issue(s) were found; inspect this Check's Records${truncation}.`;
+}
+
+function unavailable(
+  code: JsonSchemaValidationUnavailableCode
+): CheckResult<JsonSchemaValidationFinalData> {
+  return Object.freeze({
+    status: "unavailable",
+    reason: { code },
+    messages: Object.freeze([
+      Object.freeze({ code, level: "error" as const, message: unavailableMessage(code) })
+    ])
+  });
+}
+
+function unavailableMessage(code: JsonSchemaValidationUnavailableCode): string {
+  switch (code) {
+    case "invalid-options":
+      return "jsonSchemaValidation options are invalid; recreate the Check with jsonSchemaValidation(options) or restore its complete resolved options.";
+    case "scan-input-unavailable":
+      return "JSON Schema validation could not collect its configured project files; check the project root, permissions, and selected file source.";
+    case "document-unavailable":
+      return "A selected schema or instance document could not be read safely; check that it still exists, is readable, and was not replaced during the Run.";
+    case "reference-transport-unavailable":
+      return "An allowlisted HTTPS schema reference could not be loaded; check the allowlist, network, and remote availability.";
+    case "engine-unavailable":
+      return "The schema engine could not form a trusted complete result; check package/runtime integrity and inspect any retained issue Records.";
+    case "execution-cancelled":
+      return "JSON Schema validation was cancelled before it could form a complete result; inspect the caller's cancellation reason and retry if appropriate.";
+  }
+}

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

@@ -0,0 +1,61 @@
+import { canonicalizeJsonObject } from "../../data-boundary/canonical-data.ts";
+import {
+  hasRequiredAndOptionalRecordKeys,
+  snapshotClosedRecord
+} from "../../data-boundary/closed-values.ts";
+import {
+  resolveProjectFileSelection,
+  snapshotDefaultProjectFileSelection
+} from "../project-files/configuration.ts";
+import type { ResolvedJsonSchemaValidationOptions } from "./options.ts";
+import { validJsonSchemaValidationOptions } from "./options-validation.ts";
+
+const DEFAULT_MAXIMUM_BYTES = 1_048_576;
+
+/** 将可省略 schema registry policy 物化为完整、冻结的 execution options。 */
+export function resolveJsonSchemaValidationOptions(
+  value: unknown
+): ResolvedJsonSchemaValidationOptions | undefined {
+  const input = snapshotClosedRecord(value);
+  if (!validOptionInput(input)) return undefined;
+  const files = resolvedFiles(input.files);
+  if (files === undefined) return undefined;
+  const candidate = canonicalizeJsonObject({
+    files,
+    maximumBytes: input.maximumBytes === undefined ? DEFAULT_MAXIMUM_BYTES : input.maximumBytes,
+    schemaIdentity:
+      input.schemaIdentity === undefined ? { mode: "require-match" } : input.schemaIdentity,
+    referenceResolution:
+      input.referenceResolution === undefined ? { mode: "offline" } : input.referenceResolution,
+    schemas: input.schemas === undefined ? [] : input.schemas,
+    bindings: input.bindings === undefined ? [] : input.bindings
+  });
+  return candidate !== undefined && validJsonSchemaValidationOptions(candidate)
+    ? candidate
+    : undefined;
+}
+
+function validOptionInput(
+  input: Readonly<Record<string, unknown>> | undefined
+): input is Readonly<Record<string, unknown>> {
+  return (
+    input !== undefined &&
+    hasRequiredAndOptionalRecordKeys(input, {
+      optional: [
+        "files",
+        "maximumBytes",
+        "schemaIdentity",
+        "referenceResolution",
+        "schemas",
+        "bindings"
+      ],
+      required: []
+    })
+  );
+}
+
+function resolvedFiles(value: unknown) {
+  return value === undefined
+    ? snapshotDefaultProjectFileSelection()
+    : resolveProjectFileSelection(value);
+}