@valbuild/shared 0.96.3 → 0.97.1

package/dist/declarations/src/internal/ApiRoutes.d.ts

@@ -758,6 +758,7 @@ export declare const Api: {
                     validate_sources: z.ZodOptional<z.ZodPipe<z.ZodPipe<z.ZodArray<z.ZodString>, z.ZodTransform<string, string[]>> & z.ZodType<"true" | "false", string[], z.core.$ZodTypeInternals<"true" | "false", string[]>>, z.ZodTransform<boolean, "true" | "false">>>;
                     validate_binary_files: z.ZodOptional<z.ZodPipe<z.ZodPipe<z.ZodArray<z.ZodString>, z.ZodTransform<string, string[]>> & z.ZodType<"true" | "false", string[], z.core.$ZodTypeInternals<"true" | "false", string[]>>, z.ZodTransform<boolean, "true" | "false">>>;
                     exclude_patches: z.ZodOptional<z.ZodPipe<z.ZodPipe<z.ZodArray<z.ZodString>, z.ZodTransform<string, string[]>> & z.ZodType<"true" | "false", string[], z.core.$ZodTypeInternals<"true" | "false", string[]>>, z.ZodTransform<boolean, "true" | "false">>>;
+                    apply_patches: z.ZodOptional<z.ZodPipe<z.ZodPipe<z.ZodArray<z.ZodString>, z.ZodTransform<string, string[]>> & z.ZodType<"true" | "false", string[], z.core.$ZodTypeInternals<"true" | "false", string[]>>, z.ZodTransform<boolean, "true" | "false">>>;
                 };
                 cookies: {
                     val_session: z.ZodOptional<z.ZodString>;

package/dist/declarations/src/internal/index.d.ts

@@ -12,5 +12,6 @@ export * from "./getSitemapTree.js";
 export * from "./parseRoutePattern.js";
 export * from "./getNextAppRouterSourceFolder.js";
 export * from "./routeValidation.js";
+export * from "./resolveSchemaSourceFixes.js";
 export * from "./getErrorMessageFromUnknownJson.js";
 export * from "./zod/SerializedSchema.js";

package/dist/declarations/src/internal/resolveSchemaSourceFixes.d.ts

@@ -0,0 +1,42 @@
+import { type Json, type ModuleFilePath, type SerializedSchema, type SourcePath, type ValidationError } from "@valbuild/core";
+export type SchemaSourceSnapshot = {
+    schemas: Record<ModuleFilePath, SerializedSchema>;
+    sources: Record<ModuleFilePath, Json>;
+};
+export type RouteInfo = {
+    route: string;
+    moduleFilePath: ModuleFilePath;
+};
+export declare function getRoutesWithModulePaths(schemas: Record<ModuleFilePath, SerializedSchema>, sources: Record<ModuleFilePath, Json>): RouteInfo[];
+export declare function getRoutesOf(schemas: Record<ModuleFilePath, SerializedSchema>, sources: Record<ModuleFilePath, Json>): string[];
+export declare const levenshtein: (a: string, b: string) => number;
+export declare function findSimilar(key: string, targets: string[]): {
+    target: string;
+    distance: number;
+}[];
+export type ResolvedFix = {
+    status: "resolved";
+} | {
+    status: "remaining";
+    error: ValidationError;
+};
+/**
+ * Resolves a single `keyof:check-keys` or `router:check-route` error against
+ * the given schema/source snapshot. Returns:
+ *   - null if the error is not one of these fixes (caller should pass through)
+ *   - { status: "resolved" } if the referenced key/route is valid (drop error)
+ *   - { status: "remaining"; error } if invalid (rewritten error to surface)
+ */
+export declare function resolveSchemaSourceFixForError(error: ValidationError, snapshot: SchemaSourceSnapshot): ResolvedFix | null;
+/**
+ * Apply schema/source fix resolution across a map of validation errors.
+ *
+ * Errors with `keyof:check-keys` or `router:check-route` are resolved against
+ * the in-memory schema/source snapshot — valid references drop the error,
+ * invalid ones are rewritten with a "did you mean…" message and have their
+ * `fixes` cleared (so downstream code reports them as plain validation errors).
+ * All other errors pass through untouched.
+ *
+ * Source paths with no remaining errors are removed from the result.
+ */
+export declare function resolveSchemaSourceFixes(validationErrors: Record<SourcePath, ValidationError[]>, snapshot: SchemaSourceSnapshot): Record<SourcePath, ValidationError[]>;

package/dist/declarations/src/internal/zod/SerializedSchema.d.ts

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import { type SerializedSchema as SerializedSchemaT, type SerializedStringSchema as SerializedStringSchemaT, type SerializedLiteralSchema as SerializedLiteralSchemaT, type SerializedBooleanSchema as SerializedBooleanSchemaT, type SerializedNumberSchema as SerializedNumberSchemaT, type SerializedObjectSchema as SerializedObjectSchemaT, type SerializedArraySchema as SerializedArraySchemaT, type SerializedUnionSchema as SerializedUnionSchemaT, type SerializedRichTextSchema as SerializedRichTextSchemaT, type SerializedRichTextOptions as SerializedRichTextOptionsT, type SerializedRecordSchema as SerializedRecordSchemaT, type SerializedKeyOfSchema as SerializedKeyOfSchemaT, type SerializedRouteSchema as SerializedRouteSchemaT, type SerializedFileSchema as SerializedFileSchemaT, type SerializedDateSchema as SerializedDateSchemaT, type SerializedImageSchema as SerializedImageSchemaT } from "@valbuild/core";
+import { type SerializedSchema as SerializedSchemaT, type SerializedStringSchema as SerializedStringSchemaT, type SerializedLiteralSchema as SerializedLiteralSchemaT, type SerializedBooleanSchema as SerializedBooleanSchemaT, type SerializedNumberSchema as SerializedNumberSchemaT, type SerializedObjectSchema as SerializedObjectSchemaT, type SerializedArraySchema as SerializedArraySchemaT, type SerializedUnionSchema as SerializedUnionSchemaT, type SerializedRichTextSchema as SerializedRichTextSchemaT, type SerializedRichTextOptions as SerializedRichTextOptionsT, type SerializedRecordSchema as SerializedRecordSchemaT, type SerializedKeyOfSchema as SerializedKeyOfSchemaT, type SerializedRouteSchema as SerializedRouteSchemaT, type SerializedFileSchema as SerializedFileSchemaT, type SerializedDateSchema as SerializedDateSchemaT, type SerializedDateTimeSchema as SerializedDateTimeSchemaT, type SerializedImageSchema as SerializedImageSchemaT } from "@valbuild/core";
 export declare const SerializedStringSchema: z.ZodType<SerializedStringSchemaT>;
 export declare const SerializedLiteralSchema: z.ZodType<SerializedLiteralSchemaT>;
 export declare const SerializedBooleanSchema: z.ZodType<SerializedBooleanSchemaT>;
@@ -22,6 +22,11 @@ export declare const FileOptions: z.ZodObject<{
     accept: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 export declare const SerializedFileSchema: z.ZodType<SerializedFileSchemaT>;
+export declare const DateOptions: z.ZodObject<{
+    from: z.ZodOptional<z.ZodString>;
+    to: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
 export declare const SerializedDateSchema: z.ZodType<SerializedDateSchemaT>;
+export declare const SerializedDateTimeSchema: z.ZodType<SerializedDateTimeSchemaT>;
 export declare const SerializedRouteSchema: z.ZodType<SerializedRouteSchemaT>;
 export declare const SerializedSchema: z.ZodType<SerializedSchemaT>;

package/internal/dist/valbuild-shared-internal.cjs.dev.js

@@ -1023,16 +1023,22 @@ var SerializedStringSchema = zod.z.object({
     }).optional()
   }).optional(),
   opt: zod.z["boolean"](),
-  raw: zod.z["boolean"]()
+  raw: zod.z["boolean"](),
+  readonly: zod.z["boolean"]().optional(),
+  hidden: zod.z["boolean"]().optional()
 });
 var SerializedLiteralSchema = zod.z.object({
   type: zod.z.literal("literal"),
   value: zod.z.string(),
-  opt: zod.z["boolean"]()
+  opt: zod.z["boolean"](),
+  readonly: zod.z["boolean"]().optional(),
+  hidden: zod.z["boolean"]().optional()
 });
 var SerializedBooleanSchema = zod.z.object({
   type: zod.z.literal("boolean"),
-  opt: zod.z["boolean"]()
+  opt: zod.z["boolean"](),
+  readonly: zod.z["boolean"]().optional(),
+  hidden: zod.z["boolean"]().optional()
 });
 var SerializedNumberSchema = zod.z.object({
   type: zod.z.literal("number"),
@@ -1040,20 +1046,26 @@ var SerializedNumberSchema = zod.z.object({
     max: zod.z.number().optional(),
     min: zod.z.number().optional()
   }).optional(),
-  opt: zod.z["boolean"]()
+  opt: zod.z["boolean"](),
+  readonly: zod.z["boolean"]().optional(),
+  hidden: zod.z["boolean"]().optional()
 });
 var SerializedObjectSchema = zod.z.lazy(function () {
   return zod.z.object({
     type: zod.z.literal("object"),
     items: zod.z.record(zod.z.string(), SerializedSchema),
-    opt: zod.z["boolean"]()
+    opt: zod.z["boolean"](),
+    readonly: zod.z["boolean"]().optional(),
+    hidden: zod.z["boolean"]().optional()
   });
 });
 var SerializedArraySchema = zod.z.lazy(function () {
   return zod.z.object({
     type: zod.z.literal("array"),
     item: SerializedSchema,
-    opt: zod.z["boolean"]()
+    opt: zod.z["boolean"](),
+    readonly: zod.z["boolean"]().optional(),
+    hidden: zod.z["boolean"]().optional()
   });
 });
 var SerializedUnionSchema = zod.z.lazy(function () {
@@ -1061,12 +1073,16 @@ var SerializedUnionSchema = zod.z.lazy(function () {
     type: zod.z.literal("union"),
     key: SerializedLiteralSchema,
     items: zod.z.array(SerializedLiteralSchema),
-    opt: zod.z["boolean"]()
+    opt: zod.z["boolean"](),
+    readonly: zod.z["boolean"]().optional(),
+    hidden: zod.z["boolean"]().optional()
   }), zod.z.object({
     type: zod.z.literal("union"),
     key: zod.z.string(),
     items: zod.z.array(SerializedObjectSchema),
-    opt: zod.z["boolean"]()
+    opt: zod.z["boolean"](),
+    readonly: zod.z["boolean"]().optional(),
+    hidden: zod.z["boolean"]().optional()
   })]);
 });
 var ImageOptions = zod.z.object({
@@ -1078,7 +1094,9 @@ var ImageOptions = zod.z.object({
 var SerializedImageSchema = zod.z.object({
   type: zod.z.literal("image"),
   options: ImageOptions.optional(),
-  opt: zod.z["boolean"]()
+  opt: zod.z["boolean"](),
+  readonly: zod.z["boolean"]().optional(),
+  hidden: zod.z["boolean"]().optional()
 });
 var RichTextOptions = zod.z.lazy(function () {
   return zod.z.object({
@@ -1106,7 +1124,9 @@ var RichTextOptions = zod.z.lazy(function () {
 var SerializedRichTextSchema = zod.z.object({
   type: zod.z.literal("richtext"),
   options: RichTextOptions.optional(),
-  opt: zod.z["boolean"]()
+  opt: zod.z["boolean"](),
+  readonly: zod.z["boolean"]().optional(),
+  hidden: zod.z["boolean"]().optional()
 });
 var SerializedRecordSchema = zod.z.lazy(function () {
   return zod.z.object({
@@ -1120,7 +1140,9 @@ var SerializedRecordSchema = zod.z.lazy(function () {
     directory: zod.z.string().optional(),
     remote: zod.z["boolean"]().optional(),
     alt: SerializedSchema.optional(),
-    moduleMetadata: zod.z.record(zod.z.string(), zod.z.record(zod.z.string(), zod.z.any())).optional()
+    moduleMetadata: zod.z.record(zod.z.string(), zod.z.record(zod.z.string(), zod.z.any())).optional(),
+    readonly: zod.z["boolean"]().optional(),
+    hidden: zod.z["boolean"]().optional()
   }).passthrough();
 });
 var SerializedKeyOfSchema = zod.z.lazy(function () {
@@ -1136,7 +1158,9 @@ var SerializedKeyOfSchema = zod.z.lazy(function () {
       opt: zod.z["boolean"]().optional()
     })]).optional(),
     values: zod.z.union([zod.z.literal("string"), zod.z.array(zod.z.string())]),
-    opt: zod.z["boolean"]()
+    opt: zod.z["boolean"](),
+    readonly: zod.z["boolean"]().optional(),
+    hidden: zod.z["boolean"]().optional()
   });
 });
 var FileOptions = zod.z.object({
@@ -1145,11 +1169,31 @@ var FileOptions = zod.z.object({
 var SerializedFileSchema = zod.z.object({
   type: zod.z.literal("file"),
   options: FileOptions.optional(),
-  opt: zod.z["boolean"]()
+  opt: zod.z["boolean"](),
+  readonly: zod.z["boolean"]().optional(),
+  hidden: zod.z["boolean"]().optional()
+});
+var DateOptions = zod.z.object({
+  from: zod.z.string().optional(),
+  to: zod.z.string().optional()
 });
 var SerializedDateSchema = zod.z.object({
   type: zod.z.literal("date"),
-  opt: zod.z["boolean"]()
+  options: DateOptions.optional(),
+  opt: zod.z["boolean"](),
+  customValidate: zod.z["boolean"]().optional(),
+  readonly: zod.z["boolean"]().optional(),
+  hidden: zod.z["boolean"]().optional(),
+  description: zod.z.string().optional()
+});
+var SerializedDateTimeSchema = zod.z.object({
+  type: zod.z.literal("dateTime"),
+  options: DateOptions.optional(),
+  opt: zod.z["boolean"](),
+  customValidate: zod.z["boolean"]().optional(),
+  readonly: zod.z["boolean"]().optional(),
+  hidden: zod.z["boolean"]().optional(),
+  description: zod.z.string().optional()
 });
 var SerializedRouteSchema = zod.z.object({
   type: zod.z.literal("route"),
@@ -1165,9 +1209,11 @@ var SerializedRouteSchema = zod.z.object({
     customValidate: zod.z["boolean"]().optional()
   }).optional(),
   opt: zod.z["boolean"](),
-  customValidate: zod.z["boolean"]().optional()
+  customValidate: zod.z["boolean"]().optional(),
+  readonly: zod.z["boolean"]().optional(),
+  hidden: zod.z["boolean"]().optional()
 });
-var SerializedSchema = zod.z.union([SerializedStringSchema, SerializedLiteralSchema, SerializedBooleanSchema, SerializedNumberSchema, SerializedObjectSchema, SerializedArraySchema, SerializedUnionSchema, SerializedRichTextSchema, SerializedRecordSchema, SerializedKeyOfSchema, SerializedRouteSchema, SerializedFileSchema, SerializedDateSchema, SerializedImageSchema]);
+var SerializedSchema = zod.z.union([SerializedStringSchema, SerializedLiteralSchema, SerializedBooleanSchema, SerializedNumberSchema, SerializedObjectSchema, SerializedArraySchema, SerializedUnionSchema, SerializedRichTextSchema, SerializedRecordSchema, SerializedKeyOfSchema, SerializedRouteSchema, SerializedFileSchema, SerializedDateSchema, SerializedDateTimeSchema, SerializedImageSchema]);
 
 var ValCommit = zod.z.object({
   commitSha: zod.z.string(),
@@ -1795,7 +1841,8 @@ var Api = {
         query: {
           validate_sources: onlyOneBooleanQueryParam.optional(),
           validate_binary_files: onlyOneBooleanQueryParam.optional(),
-          exclude_patches: onlyOneBooleanQueryParam.optional()
+          exclude_patches: onlyOneBooleanQueryParam.optional(),
+          apply_patches: onlyOneBooleanQueryParam.optional()
         },
         cookies: {
           val_session: zod.z.string().optional()
@@ -1832,7 +1879,7 @@ var Api = {
             source: zod.z.any().optional(),
             //.optional(), // TODO: Json zod type
             baseSource: zod.z.any().optional(),
-            // pre-patch source for compare view; set only when the module has pending patches
+            // pre-patch source for compare view; only set when the server applies patches (apply_patches=true) and the module has pending patches
             patches: zod.z.object({
               applied: zod.z.array(PatchId),
               skipped: zod.z.array(PatchId).optional(),
@@ -2748,8 +2795,384 @@ function createRegExpFromPattern(pattern) {
   }
 }
 
+var TYPE_ERROR_MESSAGE = "This is most likely a Val version mismatch or Val bug.";
+function getRoutesWithModulePaths(schemas, sources) {
+  var routeMap = new Map();
+  for (var moduleFilePathS in schemas) {
+    var moduleFilePath = moduleFilePathS;
+    var schema = schemas[moduleFilePath];
+    var source = sources[moduleFilePath];
+    if (schema && schema.type === "record" && schema.router && source && _typeof(source) === "object" && !Array.isArray(source)) {
+      for (var key in source) {
+        if (!routeMap.has(key)) {
+          routeMap.set(key, moduleFilePath);
+        }
+      }
+    }
+  }
+  var routes = Array.from(routeMap.entries()).map(function (_ref) {
+    var _ref2 = _slicedToArray(_ref, 2),
+      route = _ref2[0],
+      moduleFilePath = _ref2[1];
+    return {
+      route: route,
+      moduleFilePath: moduleFilePath
+    };
+  });
+  return routes.sort(function (a, b) {
+    return a.route.localeCompare(b.route);
+  });
+}
+function getRoutesOf(schemas, sources) {
+  return getRoutesWithModulePaths(schemas, sources).map(function (r) {
+    return r.route;
+  });
+}
+
+// GPT generated levenshtein distance algorithm
+var levenshtein = function levenshtein(a, b) {
+  var _ref3 = [a.length, b.length],
+    m = _ref3[0],
+    n = _ref3[1];
+  if (!m || !n) return Math.max(m, n);
+  var dp = Array.from({
+    length: m + 1
+  }, function (_, i) {
+    return i;
+  });
+  for (var j = 1; j <= n; j++) {
+    var prev = dp[0];
+    dp[0] = j;
+    for (var i = 1; i <= m; i++) {
+      var temp = dp[i];
+      dp[i] = a[i - 1] === b[j - 1] ? prev : Math.min(prev + 1, dp[i - 1] + 1, dp[i] + 1);
+      prev = temp;
+    }
+  }
+  return dp[m];
+};
+function findSimilar(key, targets) {
+  return targets.map(function (target) {
+    return {
+      target: target,
+      distance: levenshtein(key, target)
+    };
+  }).sort(function (a, b) {
+    return a.distance - b.distance;
+  });
+}
+function getKeyOfRecordAt(sourcePath, snapshot) {
+  var _Internal$splitModule = core.Internal.splitModuleFilePathAndModulePath(sourcePath),
+    _Internal$splitModule2 = _slicedToArray(_Internal$splitModule, 2),
+    moduleFilePath = _Internal$splitModule2[0],
+    modulePath = _Internal$splitModule2[1];
+  var moduleSource = snapshot.sources[moduleFilePath];
+  var moduleSchema = snapshot.schemas[moduleFilePath];
+  if (!moduleSchema || moduleSource === undefined) {
+    return {
+      source: undefined,
+      schema: undefined
+    };
+  }
+  if (!modulePath) {
+    return {
+      source: moduleSource,
+      schema: moduleSchema
+    };
+  }
+  // Walk both schema and source. This intentionally only follows the
+  // patterns produced by keyOf().sourcePath — typically a top-level record or
+  // an object property pointing at a record. The walk is best-effort and
+  // returns undefined source on any mismatch.
+  var source = moduleSource;
+  var schema = moduleSchema;
+  var _iterator = _createForOfIteratorHelper(core.Internal.splitModulePath(modulePath)),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var part = _step.value;
+      if (source && _typeof(source) === "object" && !Array.isArray(source) && part in source) {
+        source = source[part];
+      } else {
+        source = undefined;
+      }
+      if (schema && schema.type === "object" && schema.items[part]) {
+        schema = schema.items[part];
+      } else if (schema && schema.type === "record") {
+        schema = schema.item;
+      } else {
+        schema = undefined;
+      }
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  return {
+    source: source,
+    schema: schema
+  };
+}
+function checkKeyIsValid(key, sourcePath, snapshot) {
+  var _getKeyOfRecordAt = getKeyOfRecordAt(sourcePath, snapshot),
+    keyOfModuleSource = _getKeyOfRecordAt.source,
+    keyOfModuleSchema = _getKeyOfRecordAt.schema;
+  if (keyOfModuleSchema && keyOfModuleSchema.type !== "record") {
+    return {
+      error: true,
+      message: "Expected key at ".concat(sourcePath, " to be of type 'record'")
+    };
+  }
+  if (keyOfModuleSource && _typeof(keyOfModuleSource) === "object" && !Array.isArray(keyOfModuleSource) && key in keyOfModuleSource) {
+    return {
+      error: false
+    };
+  }
+  if (!keyOfModuleSource || _typeof(keyOfModuleSource) !== "object" || Array.isArray(keyOfModuleSource)) {
+    return {
+      error: true,
+      message: "Expected ".concat(sourcePath, " to be a truthy object")
+    };
+  }
+  var alternatives = findSimilar(key, Object.keys(keyOfModuleSource));
+  if (alternatives.length === 0) {
+    return {
+      error: true,
+      message: "Key '".concat(key, "' does not exist in ").concat(sourcePath, ".")
+    };
+  }
+  return {
+    error: true,
+    message: "Key '".concat(key, "' does not exist in ").concat(sourcePath, ". Closest match: '").concat(alternatives[0].target, "'. Other similar: ").concat(alternatives.slice(1, 4).map(function (a) {
+      return "'".concat(a.target, "'");
+    }).join(", ")).concat(alternatives.length > 4 ? ", ..." : "")
+  };
+}
+function checkRouteIsValid(route, includePattern, excludePattern, snapshot) {
+  var routerModules = {};
+  for (var moduleFilePathS in snapshot.schemas) {
+    var moduleFilePath = moduleFilePathS;
+    var schema = snapshot.schemas[moduleFilePath];
+    if ((schema === null || schema === void 0 ? void 0 : schema.type) === "record" && schema.router) {
+      var source = snapshot.sources[moduleFilePath];
+      if (source && _typeof(source) === "object" && !Array.isArray(source)) {
+        routerModules[moduleFilePath] = Object.keys(source);
+      }
+    }
+  }
+  var moduleEntries = Object.entries(routerModules);
+  var foundInModule = null;
+  for (var _i = 0, _moduleEntries = moduleEntries; _i < _moduleEntries.length; _i++) {
+    var _moduleEntries$_i = _slicedToArray(_moduleEntries[_i], 2),
+      _moduleFilePath = _moduleEntries$_i[0],
+      routes = _moduleEntries$_i[1];
+    if (routes.includes(route)) {
+      foundInModule = _moduleFilePath;
+      break;
+    }
+  }
+  if (!foundInModule) {
+    var allRoutes = moduleEntries.flatMap(function (_ref4) {
+      var _ref5 = _slicedToArray(_ref4, 2),
+        routes = _ref5[1];
+      return routes;
+    });
+    if (allRoutes.length === 0) {
+      return {
+        error: true,
+        message: "Route '".concat(route, "' could not be validated: No router modules found in the project. Use s.record(...).router(...) to define router modules.")
+      };
+    }
+    allRoutes = filterRoutesByPatterns(allRoutes, includePattern, excludePattern);
+    var alternatives = findSimilar(route, allRoutes);
+    return {
+      error: true,
+      message: "Route '".concat(route, "' does not exist in any router module. ").concat(alternatives.length > 0 ? "Closest match: '".concat(alternatives[0].target, "'. Other similar: ").concat(alternatives.slice(1, 4).map(function (a) {
+        return "'".concat(a.target, "'");
+      }).join(", ")).concat(alternatives.length > 4 ? ", ..." : "") : "No similar routes found.")
+    };
+  }
+  var patternValidation = validateRoutePatterns(route, includePattern, excludePattern);
+  if (!patternValidation.valid) {
+    return {
+      error: true,
+      message: patternValidation.message
+    };
+  }
+  return {
+    error: false
+  };
+}
+/**
+ * Resolves a single `keyof:check-keys` or `router:check-route` error against
+ * the given schema/source snapshot. Returns:
+ *   - null if the error is not one of these fixes (caller should pass through)
+ *   - { status: "resolved" } if the referenced key/route is valid (drop error)
+ *   - { status: "remaining"; error } if invalid (rewritten error to surface)
+ */
+function resolveSchemaSourceFixForError(error, snapshot) {
+  var _error$fixes;
+  var fixes = (_error$fixes = error.fixes) !== null && _error$fixes !== void 0 ? _error$fixes : [];
+  if (fixes.includes("keyof:check-keys")) {
+    if (!error.value) {
+      return {
+        status: "remaining",
+        error: _objectSpread2(_objectSpread2({}, error), {}, {
+          message: "Could not find a value for keyOf. ".concat(TYPE_ERROR_MESSAGE),
+          typeError: true,
+          fixes: undefined
+        })
+      };
+    }
+    if (_typeof(error.value) !== "object") {
+      return {
+        status: "remaining",
+        error: _objectSpread2(_objectSpread2({}, error), {}, {
+          message: "Expected keyOf validation error to have a 'value' property of type 'object'. Found: ".concat(_typeof(error.value), ". ").concat(TYPE_ERROR_MESSAGE),
+          typeError: true,
+          fixes: undefined
+        })
+      };
+    }
+    var valueObj = error.value;
+    var key = valueObj.key;
+    var valueSourcePath = valueObj.sourcePath;
+    if (typeof key !== "string") {
+      return {
+        status: "remaining",
+        error: _objectSpread2(_objectSpread2({}, error), {}, {
+          message: "Expected keyOf validation error 'value' to have property 'key' of type 'string'. Found: ".concat(_typeof(key), ". ").concat(TYPE_ERROR_MESSAGE),
+          typeError: true,
+          fixes: undefined
+        })
+      };
+    }
+    if (typeof valueSourcePath !== "string") {
+      return {
+        status: "remaining",
+        error: _objectSpread2(_objectSpread2({}, error), {}, {
+          message: "Expected keyOf validation error 'value' to have property 'sourcePath' of type 'string'. Found: ".concat(_typeof(valueSourcePath), ". ").concat(TYPE_ERROR_MESSAGE),
+          typeError: true,
+          fixes: undefined
+        })
+      };
+    }
+    var res = checkKeyIsValid(key, valueSourcePath, snapshot);
+    if (res.error) {
+      return {
+        status: "remaining",
+        error: _objectSpread2(_objectSpread2({}, error), {}, {
+          message: res.message,
+          fixes: undefined
+        })
+      };
+    }
+    return {
+      status: "resolved"
+    };
+  }
+  if (fixes.includes("router:check-route")) {
+    if (!error.value) {
+      return {
+        status: "remaining",
+        error: _objectSpread2(_objectSpread2({}, error), {}, {
+          message: "Could not find a value for route. ".concat(TYPE_ERROR_MESSAGE),
+          typeError: true,
+          fixes: undefined
+        })
+      };
+    }
+    if (_typeof(error.value) !== "object") {
+      return {
+        status: "remaining",
+        error: _objectSpread2(_objectSpread2({}, error), {}, {
+          message: "Expected route validation error to have a 'value' property of type 'object'. Found: ".concat(_typeof(error.value), ". ").concat(TYPE_ERROR_MESSAGE),
+          typeError: true,
+          fixes: undefined
+        })
+      };
+    }
+    var _valueObj = error.value;
+    var route = _valueObj.route;
+    if (typeof route !== "string") {
+      return {
+        status: "remaining",
+        error: _objectSpread2(_objectSpread2({}, error), {}, {
+          message: "Expected route validation error 'value' to have property 'route' of type 'string'. Found: ".concat(_typeof(route), ". ").concat(TYPE_ERROR_MESSAGE),
+          typeError: true,
+          fixes: undefined
+        })
+      };
+    }
+    var include = asRegExpPattern(_valueObj.include);
+    var exclude = asRegExpPattern(_valueObj.exclude);
+    var _res = checkRouteIsValid(route, include, exclude, snapshot);
+    if (_res.error) {
+      return {
+        status: "remaining",
+        error: _objectSpread2(_objectSpread2({}, error), {}, {
+          message: _res.message,
+          fixes: undefined
+        })
+      };
+    }
+    return {
+      status: "resolved"
+    };
+  }
+  return null;
+}
+function asRegExpPattern(value) {
+  if (value && _typeof(value) === "object" && "source" in value && "flags" in value && typeof value.source === "string" && typeof value.flags === "string") {
+    return value;
+  }
+  return undefined;
+}
+
+/**
+ * Apply schema/source fix resolution across a map of validation errors.
+ *
+ * Errors with `keyof:check-keys` or `router:check-route` are resolved against
+ * the in-memory schema/source snapshot — valid references drop the error,
+ * invalid ones are rewritten with a "did you mean…" message and have their
+ * `fixes` cleared (so downstream code reports them as plain validation errors).
+ * All other errors pass through untouched.
+ *
+ * Source paths with no remaining errors are removed from the result.
+ */
+function resolveSchemaSourceFixes(validationErrors, snapshot) {
+  var result = {};
+  for (var sourcePathS in validationErrors) {
+    var sourcePath = sourcePathS;
+    var remaining = [];
+    var _iterator2 = _createForOfIteratorHelper(validationErrors[sourcePath]),
+      _step2;
+    try {
+      for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+        var error = _step2.value;
+        var resolved = resolveSchemaSourceFixForError(error, snapshot);
+        if (resolved === null) {
+          remaining.push(error);
+        } else if (resolved.status === "remaining") {
+          remaining.push(resolved.error);
+        }
+      }
+    } catch (err) {
+      _iterator2.e(err);
+    } finally {
+      _iterator2.f();
+    }
+    if (remaining.length > 0) {
+      result[sourcePath] = remaining;
+    }
+  }
+  return result;
+}
+
 exports.Api = Api;
 exports.DEFAULT_ERROR_MESSAGE = DEFAULT_ERROR_MESSAGE;
+exports.DateOptions = DateOptions;
 exports.FileOptions = FileOptions;
 exports.ImageOptions = ImageOptions;
 exports.ParentRef = ParentRef$1;
@@ -2772,6 +3195,7 @@ exports.RichTextOptions = RichTextOptions;
 exports.SerializedArraySchema = SerializedArraySchema;
 exports.SerializedBooleanSchema = SerializedBooleanSchema;
 exports.SerializedDateSchema = SerializedDateSchema;
+exports.SerializedDateTimeSchema = SerializedDateTimeSchema;
 exports.SerializedFileSchema = SerializedFileSchema;
 exports.SerializedImageSchema = SerializedImageSchema;
 exports.SerializedKeyOfSchema = SerializedKeyOfSchema;
@@ -2795,12 +3219,18 @@ exports.ValDeployment = ValDeployment;
 exports.createRegExpFromPattern = createRegExpFromPattern;
 exports.createValClient = createValClient;
 exports.filterRoutesByPatterns = filterRoutesByPatterns;
+exports.findSimilar = findSimilar;
 exports.getErrorMessageFromUnknownJson = getErrorMessageFromUnknownJson;
 exports.getNextAppRouterSitemapTree = getNextAppRouterSitemapTree;
 exports.getNextAppRouterSourceFolder = getNextAppRouterSourceFolder;
 exports.getPatternFromModuleFilePath = getPatternFromModuleFilePath;
+exports.getRoutesOf = getRoutesOf;
+exports.getRoutesWithModulePaths = getRoutesWithModulePaths;
+exports.levenshtein = levenshtein;
 exports.parseRoutePattern = parseRoutePattern;
 exports.remirrorToRichTextSource = remirrorToRichTextSource;
+exports.resolveSchemaSourceFixForError = resolveSchemaSourceFixForError;
+exports.resolveSchemaSourceFixes = resolveSchemaSourceFixes;
 exports.richTextToRemirror = richTextToRemirror;
 exports.urlOf = urlOf;
 exports.validateRoutePatterns = validateRoutePatterns;