@valbuild/cli 0.99.1 → 0.100.0

package/cli/dist/valbuild-cli-cli.cjs.dev.js

@@ -500,6 +500,51 @@ async function handleCheckAllFiles(ctx) {
     shouldApplyPatch: true
   };
 }
+async function handleJsonValuesExtractEntry(ctx) {
+  const [, modulePath] = core.Internal.splitModuleFilePathAndModulePath(ctx.sourcePath);
+  const parts = core.Internal.splitModulePath(modulePath);
+  // Root-only by contract (see findNestedJsonValuesRecords): the entry is a
+  // direct child of the module's root record/router, so the path is one segment.
+  if (parts.length !== 1) {
+    return {
+      success: false,
+      errorMessage: `Cannot extract .jsonValues() entry at ${ctx.sourcePath}: expected a root record entry`
+    };
+  }
+  const entryKey = parts[0];
+  const source = ctx.valModule.source;
+  if (source === null || typeof source !== "object" || Array.isArray(source)) {
+    return {
+      success: false,
+      errorMessage: `Could not get source for ${ctx.moduleFilePath}`
+    };
+  }
+  const content = source[entryKey];
+  if (content === undefined) {
+    return {
+      success: false,
+      errorMessage: `Could not find .jsonValues() entry '${entryKey}' in ${ctx.moduleFilePath}`
+    };
+  }
+  if (!ctx.fix) {
+    return {
+      success: true,
+      fixableErrorMessage: ctx.validationError.message
+    };
+  }
+  try {
+    server.extractJsonValuesEntry(ctx.moduleFilePath, ctx.projectRoot, entryKey, content, ctx.service.sourceFileHandler);
+  } catch (err) {
+    return {
+      success: false,
+      errorMessage: err instanceof Error ? err.message : String(err)
+    };
+  }
+  return {
+    success: true,
+    appliedFix: true
+  };
+}
 
 // Fix handler registry. `keyof:check-keys` and `router:check-route` are
 // resolved upfront by the shared resolveSchemaSourceFixes — they never reach
@@ -522,7 +567,8 @@ const currentFixHandlers = {
   "images:check-unique-folder": handleUniqueFolderCheck,
   "files:check-unique-folder": handleUniqueFolderCheck,
   "images:check-all-files": handleCheckAllFiles,
-  "files:check-all-files": handleCheckAllFiles
+  "files:check-all-files": handleCheckAllFiles,
+  "jsonValues:extract-entry": handleJsonValuesExtractEntry
 };
 const deprecatedFixHandlers = {
   "image:replace-metadata": handleFileMetadata
@@ -696,6 +742,26 @@ async function* runValidation({
                 fileErrors += 1;
                 continue;
               }
+              if (result.appliedFix) {
+                fixedErrors += 1;
+                yield {
+                  type: "fix-applied",
+                  file,
+                  sourcePath
+                };
+              }
+              if (result.fixableErrorMessage !== undefined) {
+                fileErrors += 1;
+                yield {
+                  type: "validation-fixable-error",
+                  sourcePath,
+                  message: result.fixableErrorMessage,
+                  fixable: true,
+                  ...(v.keyError ? {
+                    keyError: true
+                  } : {})
+                };
+              }
 
               // Apply patch if needed
               if (result.shouldApplyPatch) {
@@ -855,19 +921,34 @@ function resolveRange(sourcePath, projectRoot, cache, target) {
     return undefined;
   }
   const range = server.getModulePathRange(modulePath, cached.map, target);
-  if (!range) {
-    return undefined;
+  if (range) {
+    return {
+      relativeFile: moduleFilePath.replace(/^\//, ""),
+      lines: cached.lines,
+      range: clampRange(range)
+    };
   }
+  // Nothing in the `.val.ts` matches — which is the normal case for a
+  // `.jsonValues()` entry, since the value lives in its own `*.val.json` and the
+  // `.val.ts` only holds the `c.json(() => import(...))` thunk. Follow it.
+  const entryResolved = resolveJsonEntryRange(moduleFilePath, modulePath, projectRoot, cache, target, cached);
+  // Clamped here too: an entry's range comes from the same resolver, run against
+  // the entry's `*.val.json`, so it can be just as bad.
+  return entryResolved && {
+    ...entryResolved,
+    range: clampRange(entryResolved.range)
+  };
+}
+
+/**
+ * Defensive: a bad range must degrade to an odd-looking frame, never a crash —
+ * the caret math in the code frame does `" ".repeat(start.character)`, which
+ * throws a RangeError on a negative count.
+ */
+function clampRange(range) {
   return {
-    relativeFile: moduleFilePath.replace(/^\//, ""),
-    lines: cached.lines,
-    // Defensive: a bad range must degrade to an odd-looking frame, never a
-    // crash - the caret math below does `" ".repeat(start.character)`, which
-    // throws a RangeError on a negative count.
-    range: {
-      start: clampPosition(range.start),
-      end: clampPosition(range.end)
-    }
+    start: clampPosition(range.start),
+    end: clampPosition(range.end)
   };
 }
 function clampPosition(position) {
@@ -876,6 +957,89 @@ function clampPosition(position) {
     character: Math.max(0, position.character)
   };
 }
+
+/**
+ * Resolves the part of a source path BELOW a `.jsonValues()` entry key against
+ * the entry's backing `*.val.json`.
+ *
+ * Without this a validation error in an entry has no location at all: for a
+ * record with hundreds of entries the report would name the module and the rule
+ * but not which entry, which is barely a report.
+ */
+function resolveJsonEntryRange(moduleFilePath, modulePath, projectRoot, cache, target, cachedModule) {
+  if (!modulePath || !cachedModule.sourceFile) {
+    return undefined;
+  }
+  let segments;
+  try {
+    segments = core.Internal.splitModulePath(modulePath);
+  } catch {
+    return undefined;
+  }
+  const [entryKey, ...rest] = segments;
+  if (entryKey === undefined) {
+    return undefined;
+  }
+  const jsonFilePath = server.findJsonEntryFilePath(moduleFilePath, cachedModule.sourceFile, entryKey);
+  if (!jsonFilePath) {
+    return undefined;
+  }
+  const cachedJson = getCachedJsonFile(jsonFilePath, projectRoot, cache);
+  if (!cachedJson) {
+    return undefined;
+  }
+  const relativeFile = jsonFilePath.replace(/^\//, "");
+  if (rest.length === 0) {
+    // The error is on the entry as a whole (e.g. it failed to load): point at the
+    // top of its file rather than nowhere.
+    return {
+      relativeFile,
+      lines: cachedJson.lines,
+      range: {
+        start: {
+          line: 0,
+          character: 0
+        },
+        end: {
+          line: 0,
+          character: 0
+        }
+      }
+    };
+  }
+  if (!cachedJson.map) {
+    return undefined;
+  }
+  const range = server.getModulePathRange(rest.map(segment => JSON.stringify(segment)).join("."), cachedJson.map, target);
+  if (!range) {
+    return undefined;
+  }
+  return {
+    relativeFile,
+    lines: cachedJson.lines,
+    range
+  };
+}
+function getCachedJsonFile(jsonFilePath, projectRoot, cache) {
+  const existing = cache.get(jsonFilePath);
+  if (existing !== undefined) {
+    return existing;
+  }
+  const filePath = path__default["default"].join(projectRoot, jsonFilePath);
+  let fileContent;
+  try {
+    fileContent = fs__default["default"].readFileSync(filePath, "utf-8");
+  } catch {
+    cache.set(jsonFilePath, null);
+    return null;
+  }
+  const entry = {
+    lines: fileContent.split(/\r?\n/),
+    map: server.createJsonEntryPathMap(ts__default["default"].parseJsonText(filePath, fileContent))
+  };
+  cache.set(jsonFilePath, entry);
+  return entry;
+}
 function getCachedFile(moduleFilePath, projectRoot, cache) {
   const existing = cache.get(moduleFilePath);
   if (existing !== undefined) {
@@ -892,7 +1056,8 @@ function getCachedFile(moduleFilePath, projectRoot, cache) {
   const sourceFile = ts__default["default"].createSourceFile(filePath, fileContent, ts__default["default"].ScriptTarget.ES2015);
   const entry = {
     lines: fileContent.split(/\r?\n/),
-    map: server.createModulePathMap(sourceFile)
+    map: server.createModulePathMap(sourceFile),
+    sourceFile
   };
   cache.set(moduleFilePath, entry);
   return entry;

package/cli/dist/valbuild-cli-cli.cjs.prod.js

@@ -500,6 +500,51 @@ async function handleCheckAllFiles(ctx) {
     shouldApplyPatch: true
   };
 }
+async function handleJsonValuesExtractEntry(ctx) {
+  const [, modulePath] = core.Internal.splitModuleFilePathAndModulePath(ctx.sourcePath);
+  const parts = core.Internal.splitModulePath(modulePath);
+  // Root-only by contract (see findNestedJsonValuesRecords): the entry is a
+  // direct child of the module's root record/router, so the path is one segment.
+  if (parts.length !== 1) {
+    return {
+      success: false,
+      errorMessage: `Cannot extract .jsonValues() entry at ${ctx.sourcePath}: expected a root record entry`
+    };
+  }
+  const entryKey = parts[0];
+  const source = ctx.valModule.source;
+  if (source === null || typeof source !== "object" || Array.isArray(source)) {
+    return {
+      success: false,
+      errorMessage: `Could not get source for ${ctx.moduleFilePath}`
+    };
+  }
+  const content = source[entryKey];
+  if (content === undefined) {
+    return {
+      success: false,
+      errorMessage: `Could not find .jsonValues() entry '${entryKey}' in ${ctx.moduleFilePath}`
+    };
+  }
+  if (!ctx.fix) {
+    return {
+      success: true,
+      fixableErrorMessage: ctx.validationError.message
+    };
+  }
+  try {
+    server.extractJsonValuesEntry(ctx.moduleFilePath, ctx.projectRoot, entryKey, content, ctx.service.sourceFileHandler);
+  } catch (err) {
+    return {
+      success: false,
+      errorMessage: err instanceof Error ? err.message : String(err)
+    };
+  }
+  return {
+    success: true,
+    appliedFix: true
+  };
+}
 
 // Fix handler registry. `keyof:check-keys` and `router:check-route` are
 // resolved upfront by the shared resolveSchemaSourceFixes — they never reach
@@ -522,7 +567,8 @@ const currentFixHandlers = {
   "images:check-unique-folder": handleUniqueFolderCheck,
   "files:check-unique-folder": handleUniqueFolderCheck,
   "images:check-all-files": handleCheckAllFiles,
-  "files:check-all-files": handleCheckAllFiles
+  "files:check-all-files": handleCheckAllFiles,
+  "jsonValues:extract-entry": handleJsonValuesExtractEntry
 };
 const deprecatedFixHandlers = {
   "image:replace-metadata": handleFileMetadata
@@ -696,6 +742,26 @@ async function* runValidation({
                 fileErrors += 1;
                 continue;
               }
+              if (result.appliedFix) {
+                fixedErrors += 1;
+                yield {
+                  type: "fix-applied",
+                  file,
+                  sourcePath
+                };
+              }
+              if (result.fixableErrorMessage !== undefined) {
+                fileErrors += 1;
+                yield {
+                  type: "validation-fixable-error",
+                  sourcePath,
+                  message: result.fixableErrorMessage,
+                  fixable: true,
+                  ...(v.keyError ? {
+                    keyError: true
+                  } : {})
+                };
+              }
 
               // Apply patch if needed
               if (result.shouldApplyPatch) {
@@ -855,19 +921,34 @@ function resolveRange(sourcePath, projectRoot, cache, target) {
     return undefined;
   }
   const range = server.getModulePathRange(modulePath, cached.map, target);
-  if (!range) {
-    return undefined;
+  if (range) {
+    return {
+      relativeFile: moduleFilePath.replace(/^\//, ""),
+      lines: cached.lines,
+      range: clampRange(range)
+    };
   }
+  // Nothing in the `.val.ts` matches — which is the normal case for a
+  // `.jsonValues()` entry, since the value lives in its own `*.val.json` and the
+  // `.val.ts` only holds the `c.json(() => import(...))` thunk. Follow it.
+  const entryResolved = resolveJsonEntryRange(moduleFilePath, modulePath, projectRoot, cache, target, cached);
+  // Clamped here too: an entry's range comes from the same resolver, run against
+  // the entry's `*.val.json`, so it can be just as bad.
+  return entryResolved && {
+    ...entryResolved,
+    range: clampRange(entryResolved.range)
+  };
+}
+
+/**
+ * Defensive: a bad range must degrade to an odd-looking frame, never a crash —
+ * the caret math in the code frame does `" ".repeat(start.character)`, which
+ * throws a RangeError on a negative count.
+ */
+function clampRange(range) {
   return {
-    relativeFile: moduleFilePath.replace(/^\//, ""),
-    lines: cached.lines,
-    // Defensive: a bad range must degrade to an odd-looking frame, never a
-    // crash - the caret math below does `" ".repeat(start.character)`, which
-    // throws a RangeError on a negative count.
-    range: {
-      start: clampPosition(range.start),
-      end: clampPosition(range.end)
-    }
+    start: clampPosition(range.start),
+    end: clampPosition(range.end)
   };
 }
 function clampPosition(position) {
@@ -876,6 +957,89 @@ function clampPosition(position) {
     character: Math.max(0, position.character)
   };
 }
+
+/**
+ * Resolves the part of a source path BELOW a `.jsonValues()` entry key against
+ * the entry's backing `*.val.json`.
+ *
+ * Without this a validation error in an entry has no location at all: for a
+ * record with hundreds of entries the report would name the module and the rule
+ * but not which entry, which is barely a report.
+ */
+function resolveJsonEntryRange(moduleFilePath, modulePath, projectRoot, cache, target, cachedModule) {
+  if (!modulePath || !cachedModule.sourceFile) {
+    return undefined;
+  }
+  let segments;
+  try {
+    segments = core.Internal.splitModulePath(modulePath);
+  } catch {
+    return undefined;
+  }
+  const [entryKey, ...rest] = segments;
+  if (entryKey === undefined) {
+    return undefined;
+  }
+  const jsonFilePath = server.findJsonEntryFilePath(moduleFilePath, cachedModule.sourceFile, entryKey);
+  if (!jsonFilePath) {
+    return undefined;
+  }
+  const cachedJson = getCachedJsonFile(jsonFilePath, projectRoot, cache);
+  if (!cachedJson) {
+    return undefined;
+  }
+  const relativeFile = jsonFilePath.replace(/^\//, "");
+  if (rest.length === 0) {
+    // The error is on the entry as a whole (e.g. it failed to load): point at the
+    // top of its file rather than nowhere.
+    return {
+      relativeFile,
+      lines: cachedJson.lines,
+      range: {
+        start: {
+          line: 0,
+          character: 0
+        },
+        end: {
+          line: 0,
+          character: 0
+        }
+      }
+    };
+  }
+  if (!cachedJson.map) {
+    return undefined;
+  }
+  const range = server.getModulePathRange(rest.map(segment => JSON.stringify(segment)).join("."), cachedJson.map, target);
+  if (!range) {
+    return undefined;
+  }
+  return {
+    relativeFile,
+    lines: cachedJson.lines,
+    range
+  };
+}
+function getCachedJsonFile(jsonFilePath, projectRoot, cache) {
+  const existing = cache.get(jsonFilePath);
+  if (existing !== undefined) {
+    return existing;
+  }
+  const filePath = path__default["default"].join(projectRoot, jsonFilePath);
+  let fileContent;
+  try {
+    fileContent = fs__default["default"].readFileSync(filePath, "utf-8");
+  } catch {
+    cache.set(jsonFilePath, null);
+    return null;
+  }
+  const entry = {
+    lines: fileContent.split(/\r?\n/),
+    map: server.createJsonEntryPathMap(ts__default["default"].parseJsonText(filePath, fileContent))
+  };
+  cache.set(jsonFilePath, entry);
+  return entry;
+}
 function getCachedFile(moduleFilePath, projectRoot, cache) {
   const existing = cache.get(moduleFilePath);
   if (existing !== undefined) {
@@ -892,7 +1056,8 @@ function getCachedFile(moduleFilePath, projectRoot, cache) {
   const sourceFile = ts__default["default"].createSourceFile(filePath, fileContent, ts__default["default"].ScriptTarget.ES2015);
   const entry = {
     lines: fileContent.split(/\r?\n/),
-    map: server.createModulePathMap(sourceFile)
+    map: server.createModulePathMap(sourceFile),
+    sourceFile
   };
   cache.set(moduleFilePath, entry);
   return entry;

package/cli/dist/valbuild-cli-cli.esm.js

@@ -5,7 +5,7 @@ import pc from 'picocolors';
 import fs$1 from 'fs/promises';
 import { glob } from 'fast-glob';
 import { Internal, FILE_REF_PROP, DEFAULT_VAL_REMOTE_HOST, DEFAULT_CONTENT_HOST, VAL_EXTENSION } from '@valbuild/core';
-import { createService, createFixPatch, getPersonalAccessTokenPath, parsePersonalAccessTokenFile, getModulePathRange, createModulePathMap, findAndEvalValConfigFile, getSettings, uploadRemoteFile, startValLogin, awaitValLoginConfirmation, persistPersonalAccessToken, ValLoginError, loadValModules, safeReadGit, ValOpsHttp, ValOpsFS, formatPatchSourceError } from '@valbuild/server';
+import { createService, createFixPatch, extractJsonValuesEntry, getPersonalAccessTokenPath, parsePersonalAccessTokenFile, getModulePathRange, findJsonEntryFilePath, createJsonEntryPathMap, createModulePathMap, findAndEvalValConfigFile, getSettings, uploadRemoteFile, startValLogin, awaitValLoginConfirmation, persistPersonalAccessToken, ValLoginError, loadValModules, safeReadGit, ValOpsHttp, ValOpsFS, formatPatchSourceError } from '@valbuild/server';
 import { resolveSchemaSourceFixes } from '@valbuild/shared/internal';
 import ts from 'typescript';
 import fs from 'fs';
@@ -468,6 +468,51 @@ async function handleCheckAllFiles(ctx) {
     shouldApplyPatch: true
   };
 }
+async function handleJsonValuesExtractEntry(ctx) {
+  const [, modulePath] = Internal.splitModuleFilePathAndModulePath(ctx.sourcePath);
+  const parts = Internal.splitModulePath(modulePath);
+  // Root-only by contract (see findNestedJsonValuesRecords): the entry is a
+  // direct child of the module's root record/router, so the path is one segment.
+  if (parts.length !== 1) {
+    return {
+      success: false,
+      errorMessage: `Cannot extract .jsonValues() entry at ${ctx.sourcePath}: expected a root record entry`
+    };
+  }
+  const entryKey = parts[0];
+  const source = ctx.valModule.source;
+  if (source === null || typeof source !== "object" || Array.isArray(source)) {
+    return {
+      success: false,
+      errorMessage: `Could not get source for ${ctx.moduleFilePath}`
+    };
+  }
+  const content = source[entryKey];
+  if (content === undefined) {
+    return {
+      success: false,
+      errorMessage: `Could not find .jsonValues() entry '${entryKey}' in ${ctx.moduleFilePath}`
+    };
+  }
+  if (!ctx.fix) {
+    return {
+      success: true,
+      fixableErrorMessage: ctx.validationError.message
+    };
+  }
+  try {
+    extractJsonValuesEntry(ctx.moduleFilePath, ctx.projectRoot, entryKey, content, ctx.service.sourceFileHandler);
+  } catch (err) {
+    return {
+      success: false,
+      errorMessage: err instanceof Error ? err.message : String(err)
+    };
+  }
+  return {
+    success: true,
+    appliedFix: true
+  };
+}
 
 // Fix handler registry. `keyof:check-keys` and `router:check-route` are
 // resolved upfront by the shared resolveSchemaSourceFixes — they never reach
@@ -490,7 +535,8 @@ const currentFixHandlers = {
   "images:check-unique-folder": handleUniqueFolderCheck,
   "files:check-unique-folder": handleUniqueFolderCheck,
   "images:check-all-files": handleCheckAllFiles,
-  "files:check-all-files": handleCheckAllFiles
+  "files:check-all-files": handleCheckAllFiles,
+  "jsonValues:extract-entry": handleJsonValuesExtractEntry
 };
 const deprecatedFixHandlers = {
   "image:replace-metadata": handleFileMetadata
@@ -664,6 +710,26 @@ async function* runValidation({
                 fileErrors += 1;
                 continue;
               }
+              if (result.appliedFix) {
+                fixedErrors += 1;
+                yield {
+                  type: "fix-applied",
+                  file,
+                  sourcePath
+                };
+              }
+              if (result.fixableErrorMessage !== undefined) {
+                fileErrors += 1;
+                yield {
+                  type: "validation-fixable-error",
+                  sourcePath,
+                  message: result.fixableErrorMessage,
+                  fixable: true,
+                  ...(v.keyError ? {
+                    keyError: true
+                  } : {})
+                };
+              }
 
               // Apply patch if needed
               if (result.shouldApplyPatch) {
@@ -823,19 +889,34 @@ function resolveRange(sourcePath, projectRoot, cache, target) {
     return undefined;
   }
   const range = getModulePathRange(modulePath, cached.map, target);
-  if (!range) {
-    return undefined;
+  if (range) {
+    return {
+      relativeFile: moduleFilePath.replace(/^\//, ""),
+      lines: cached.lines,
+      range: clampRange(range)
+    };
   }
+  // Nothing in the `.val.ts` matches — which is the normal case for a
+  // `.jsonValues()` entry, since the value lives in its own `*.val.json` and the
+  // `.val.ts` only holds the `c.json(() => import(...))` thunk. Follow it.
+  const entryResolved = resolveJsonEntryRange(moduleFilePath, modulePath, projectRoot, cache, target, cached);
+  // Clamped here too: an entry's range comes from the same resolver, run against
+  // the entry's `*.val.json`, so it can be just as bad.
+  return entryResolved && {
+    ...entryResolved,
+    range: clampRange(entryResolved.range)
+  };
+}
+
+/**
+ * Defensive: a bad range must degrade to an odd-looking frame, never a crash —
+ * the caret math in the code frame does `" ".repeat(start.character)`, which
+ * throws a RangeError on a negative count.
+ */
+function clampRange(range) {
   return {
-    relativeFile: moduleFilePath.replace(/^\//, ""),
-    lines: cached.lines,
-    // Defensive: a bad range must degrade to an odd-looking frame, never a
-    // crash - the caret math below does `" ".repeat(start.character)`, which
-    // throws a RangeError on a negative count.
-    range: {
-      start: clampPosition(range.start),
-      end: clampPosition(range.end)
-    }
+    start: clampPosition(range.start),
+    end: clampPosition(range.end)
   };
 }
 function clampPosition(position) {
@@ -844,6 +925,89 @@ function clampPosition(position) {
     character: Math.max(0, position.character)
   };
 }
+
+/**
+ * Resolves the part of a source path BELOW a `.jsonValues()` entry key against
+ * the entry's backing `*.val.json`.
+ *
+ * Without this a validation error in an entry has no location at all: for a
+ * record with hundreds of entries the report would name the module and the rule
+ * but not which entry, which is barely a report.
+ */
+function resolveJsonEntryRange(moduleFilePath, modulePath, projectRoot, cache, target, cachedModule) {
+  if (!modulePath || !cachedModule.sourceFile) {
+    return undefined;
+  }
+  let segments;
+  try {
+    segments = Internal.splitModulePath(modulePath);
+  } catch {
+    return undefined;
+  }
+  const [entryKey, ...rest] = segments;
+  if (entryKey === undefined) {
+    return undefined;
+  }
+  const jsonFilePath = findJsonEntryFilePath(moduleFilePath, cachedModule.sourceFile, entryKey);
+  if (!jsonFilePath) {
+    return undefined;
+  }
+  const cachedJson = getCachedJsonFile(jsonFilePath, projectRoot, cache);
+  if (!cachedJson) {
+    return undefined;
+  }
+  const relativeFile = jsonFilePath.replace(/^\//, "");
+  if (rest.length === 0) {
+    // The error is on the entry as a whole (e.g. it failed to load): point at the
+    // top of its file rather than nowhere.
+    return {
+      relativeFile,
+      lines: cachedJson.lines,
+      range: {
+        start: {
+          line: 0,
+          character: 0
+        },
+        end: {
+          line: 0,
+          character: 0
+        }
+      }
+    };
+  }
+  if (!cachedJson.map) {
+    return undefined;
+  }
+  const range = getModulePathRange(rest.map(segment => JSON.stringify(segment)).join("."), cachedJson.map, target);
+  if (!range) {
+    return undefined;
+  }
+  return {
+    relativeFile,
+    lines: cachedJson.lines,
+    range
+  };
+}
+function getCachedJsonFile(jsonFilePath, projectRoot, cache) {
+  const existing = cache.get(jsonFilePath);
+  if (existing !== undefined) {
+    return existing;
+  }
+  const filePath = path.join(projectRoot, jsonFilePath);
+  let fileContent;
+  try {
+    fileContent = fs.readFileSync(filePath, "utf-8");
+  } catch {
+    cache.set(jsonFilePath, null);
+    return null;
+  }
+  const entry = {
+    lines: fileContent.split(/\r?\n/),
+    map: createJsonEntryPathMap(ts.parseJsonText(filePath, fileContent))
+  };
+  cache.set(jsonFilePath, entry);
+  return entry;
+}
 function getCachedFile(moduleFilePath, projectRoot, cache) {
   const existing = cache.get(moduleFilePath);
   if (existing !== undefined) {
@@ -860,7 +1024,8 @@ function getCachedFile(moduleFilePath, projectRoot, cache) {
   const sourceFile = ts.createSourceFile(filePath, fileContent, ts.ScriptTarget.ES2015);
   const entry = {
     lines: fileContent.split(/\r?\n/),
-    map: createModulePathMap(sourceFile)
+    map: createModulePathMap(sourceFile),
+    sourceFile
   };
   cache.set(moduleFilePath, entry);
   return entry;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@valbuild/cli",
   "private": false,
-  "version": "0.99.1",
+  "version": "0.100.0",
   "description": "Val CLI tools",
   "repository": {
     "type": "git",
@@ -27,11 +27,11 @@
     "open": "^9.1.0",
     "picocolors": "^1.1.1",
     "zod": "^4.3.5",
-    "@valbuild/core": "0.99.1",
+    "@valbuild/core": "0.100.0",
     "@valbuild/eslint-plugin": "0.93.0",
-    "@valbuild/language-server": "0.99.1",
-    "@valbuild/server": "0.99.1",
-    "@valbuild/shared": "0.99.1"
+    "@valbuild/language-server": "0.100.0",
+    "@valbuild/server": "0.100.0",
+    "@valbuild/shared": "0.100.0"
   },
   "peerDependencies": {
     "prettier": "*",

package/src/__fixtures__/basic/content/basic-inline-json-values-invalid.val.ts

@@ -0,0 +1,18 @@
+import { c, s } from "../val.config";
+
+/**
+ * A `.jsonValues()` record with an inline entry whose value ALSO fails the item
+ * schema at the entry's own path: the string is shorter than the minimum.
+ *
+ * Two validations report at the same source path — the record-level one (which
+ * checks the inline value against the item schema) and the jsonValues one (which
+ * reports the inlining). Both have to survive being merged into the module's
+ * validation errors.
+ */
+export default c.define(
+  "/content/basic-inline-json-values-invalid.val.ts",
+  s.record(s.string().minLength(5)).jsonValues(),
+  {
+    "/inline": "ab",
+  },
+);

package/src/__fixtures__/basic/content/basic-inline-json-values.val.ts

@@ -0,0 +1,16 @@
+import { c, s } from "../val.config";
+
+/**
+ * A `.jsonValues()` record with one entry hand-authored INLINE instead of
+ * `c.json(() => import(...))`. The types allow it on purpose (a type error there
+ * is a dead end for the author); validation reports it as
+ * `jsonValues:extract-entry` and `--fix` moves it into its own `*.val.json`.
+ */
+export default c.define(
+  "/content/basic-inline-json-values.val.ts",
+  s.record(s.object({ title: s.string(), order: s.number() })).jsonValues(),
+  {
+    "/ok": c.json(() => import("./json-entries/ok.val.json")),
+    "/inline": { title: "Written inline", order: 3 },
+  },
+);

package/src/__fixtures__/basic/content/basic-json-values.val.ts

@@ -0,0 +1,18 @@
+import { c, s } from "../val.config";
+
+/**
+ * A `.jsonValues()` record whose entry content lives in separate files. The
+ * point of the fixture: the `.val.ts` itself is always structurally valid — the
+ * only thing that can be wrong is INSIDE an entry, which is exactly what
+ * `val validate` used to miss.
+ */
+export default c.define(
+  "/content/basic-json-values.val.ts",
+  s
+    .record(s.object({ title: s.string().minLength(2), order: s.number() }))
+    .jsonValues(),
+  {
+    "/ok": c.json(() => import("./json-entries/ok.val.json")),
+    "/broken": c.json(() => import("./json-entries/broken.val.json")),
+  },
+);

package/src/__fixtures__/basic/content/basic-nested-json-values.val.ts

@@ -0,0 +1,13 @@
+import { c, s } from "../val.config";
+
+/**
+ * Rejected at validation time: `.jsonValues()` is root-only, and a nested one
+ * would silently get no content validation at all.
+ */
+export default c.define(
+  "/content/basic-nested-json-values.val.ts",
+  s.object({
+    nested: s.record(s.object({ title: s.string() })).jsonValues(),
+  }),
+  { nested: {} },
+);

package/src/__fixtures__/basic/content/json-entries/broken.val.json

@@ -0,0 +1,4 @@
+{
+  "title": "x",
+  "order": 2
+}

package/src/__fixtures__/basic/content/json-entries/ok.val.json

@@ -0,0 +1,4 @@
+{
+  "title": "A valid entry",
+  "order": 1
+}

package/src/__fixtures__/basic/val.modules.ts

@@ -15,4 +15,8 @@ export default modules(config, [
   { def: () => import("./content/basic-gallery-wrong-metadata.val") },
   { def: () => import("./content/basic-gallery-remote.val") },
   { def: () => import("./content/basic-gallery-remote-existing.val") },
+  { def: () => import("./content/basic-json-values.val") },
+  { def: () => import("./content/basic-nested-json-values.val") },
+  { def: () => import("./content/basic-inline-json-values.val") },
+  { def: () => import("./content/basic-inline-json-values-invalid.val") },
 ]);

package/src/runValidation.test.ts

@@ -484,4 +484,176 @@ describe("runValidation", () => {
     expect(events.at(-1)).toEqual({ type: "summary-success" });
     expect(events.filter((e) => e.type === "validation-error")).toHaveLength(0);
   });
+
+  describe("jsonValues", () => {
+    const runOn = async (valFiles: string[]) => {
+      const events: ValidationEvent[] = [];
+      for await (const event of runValidation({
+        root: tmpDir,
+        fix: false,
+        valFiles,
+        project: undefined,
+        remote: mockRemote,
+        fs: createDefaultValFSHost(),
+      })) {
+        events.push(event);
+      }
+      return events;
+    };
+
+    test("validates entry CONTENT, which lives outside the .val.ts", async () => {
+      // Regression: `val validate` reported a jsonValues module as valid no matter
+      // what its entries contained. The record-level schema only asserts the
+      // marker shape — deep validation is deferred to whoever loads the entry, and
+      // the CLI never did. Any project gating CI on `val validate` was blind to it.
+      //
+      // The violation here is a VALUE one (minLength), like the other fixtures in
+      // this directory: with `resolveJsonModule` on, tsc catches type-level
+      // mistakes in a hand-authored entry by itself — constraints are what only
+      // validation can see.
+      const events = await runOn(["content/basic-json-values.val.ts"]);
+      const errors = events.filter((e) => e.type === "validation-error");
+
+      // The path names the ENTRY, not just the module: for a record with
+      // hundreds of entries, "something in here is wrong" is not a report.
+      expect(errors).toEqual(
+        expect.arrayContaining([
+          expect.objectContaining({
+            sourcePath: '/content/basic-json-values.val.ts?p="/broken"."title"',
+            message: expect.stringContaining("2 characters"),
+          }),
+        ]),
+      );
+      // ...and the entry that IS valid produces nothing.
+      expect(
+        errors.filter(
+          (e) => "sourcePath" in e && e.sourcePath.includes('"/ok"'),
+        ),
+      ).toHaveLength(0);
+    });
+
+    test("reports an inlined entry as a fixable error", async () => {
+      // The types accept an inline entry (see JsonValuesRecordSrc), so validation
+      // is the thing that has to catch it — otherwise a hand-authored entry
+      // quietly stays in the `.val.ts`, where the Studio cannot edit it and the
+      // lazy-loading the record opted into does not apply.
+      const events = await runOn(["content/basic-inline-json-values.val.ts"]);
+
+      expect(events).toEqual(
+        expect.arrayContaining([
+          expect.objectContaining({
+            type: "validation-fixable-error",
+            sourcePath: '/content/basic-inline-json-values.val.ts?p="/inline"',
+            fixable: true,
+            message: expect.stringContaining("written inline"),
+          }),
+        ]),
+      );
+      expect(events.at(-1)).toEqual({ type: "summary-errors", count: 1 });
+    });
+
+    test("--fix moves an inlined entry into its own *.val.json", async () => {
+      const events: ValidationEvent[] = [];
+      for await (const event of runValidation({
+        root: tmpDir,
+        fix: true,
+        valFiles: ["content/basic-inline-json-values.val.ts"],
+        project: undefined,
+        remote: mockRemote,
+        fs: createDefaultValFSHost(),
+      })) {
+        events.push(event);
+      }
+      expect(events).toEqual(
+        expect.arrayContaining([
+          expect.objectContaining({
+            type: "fix-applied",
+            sourcePath: '/content/basic-inline-json-values.val.ts?p="/inline"',
+          }),
+        ]),
+      );
+
+      // The content moved to the conventional path for the key...
+      const jsonPath = path.join(
+        tmpDir,
+        "content/basic-inline-json-values/inline.val.json",
+      );
+      expect(JSON.parse(fs.readFileSync(jsonPath, "utf8"))).toEqual({
+        title: "Written inline",
+        order: 3,
+      });
+      // ...and the module now references it lazily, like every other entry.
+      const valTs = fs.readFileSync(
+        path.join(tmpDir, "content/basic-inline-json-values.val.ts"),
+        "utf8",
+      );
+      expect(valTs).toContain(
+        'c.json(() => import("./basic-inline-json-values/inline.val.json"))',
+      );
+      expect(valTs).not.toContain("Written inline");
+
+      // Re-validating the fixed project is clean: the fix is not just silencing
+      // the error, it produces a module that loads and validates.
+      const afterFix: ValidationEvent[] = [];
+      for await (const event of runValidation({
+        root: tmpDir,
+        fix: false,
+        valFiles: ["content/basic-inline-json-values.val.ts"],
+        project: undefined,
+        remote: mockRemote,
+        fs: createDefaultValFSHost(),
+      })) {
+        afterFix.push(event);
+      }
+      expect(afterFix.at(-1)).toEqual({ type: "summary-success" });
+    });
+
+    test("keeps the item-schema error alongside the inline-entry error", async () => {
+      // Both validations report at the SAME source path: the record-level one
+      // checks the inline value against the item schema, and the jsonValues one
+      // reports the inlining. Merging them with a spread drops one of the two,
+      // so the author fixes the inlining and only then learns the value was
+      // never valid.
+      const events = await runOn([
+        "content/basic-inline-json-values-invalid.val.ts",
+      ]);
+
+      const sourcePath =
+        '/content/basic-inline-json-values-invalid.val.ts?p="/inline"';
+      expect(events).toEqual(
+        expect.arrayContaining([
+          expect.objectContaining({
+            type: "validation-fixable-error",
+            sourcePath,
+            message: expect.stringContaining("written inline"),
+          }),
+          expect.objectContaining({
+            type: "validation-error",
+            sourcePath,
+            message: expect.stringContaining("at least 5"),
+          }),
+        ]),
+      );
+      expect(events.at(-1)).toEqual({ type: "summary-errors", count: 2 });
+    });
+
+    test("rejects a nested .jsonValues() instead of reporting it valid", async () => {
+      // Root-only is a hard contract: a nested one would silently get NO content
+      // validation. The Studio refuses to load such a project, so the CLI saying
+      // "valid" was the two entry points disagreeing.
+      const events = await runOn(["content/basic-nested-json-values.val.ts"]);
+
+      expect(events).toEqual(
+        expect.arrayContaining([
+          expect.objectContaining({
+            type: "fatal-error",
+            message: expect.stringContaining(
+              "Nested .jsonValues() records are not supported",
+            ),
+          }),
+        ]),
+      );
+      expect(events.at(-1)).not.toEqual({ type: "summary-success" });
+    });
+  });
 });

package/src/runValidation.ts

@@ -2,6 +2,7 @@ import path from "path";
 import {
   createFixPatch,
   createService,
+  extractJsonValuesEntry,
   getPersonalAccessTokenPath,
   parsePersonalAccessTokenFile,
   Service,
@@ -93,6 +94,12 @@ export type FixHandlerResult = {
   success: boolean;
   errorMessage?: string;
   shouldApplyPatch?: boolean;
+  // The handler repaired the source itself (it could not be expressed as a
+  // patch, so `shouldApplyPatch` does not apply): count it as fixed.
+  appliedFix?: boolean;
+  // The handler did nothing because `--fix` was off, but the error IS fixable:
+  // report it as such instead of as a plain validation error.
+  fixableErrorMessage?: string;
   // Updated shared state
   publicProjectId?: string;
   remoteFileBuckets?: string[];
@@ -670,6 +677,59 @@ export async function handleCheckAllFiles(
   return { success: true, shouldApplyPatch: true };
 }
 
+export async function handleJsonValuesExtractEntry(
+  ctx: FixHandlerContext,
+): Promise<FixHandlerResult> {
+  const [, modulePath] = Internal.splitModuleFilePathAndModulePath(
+    ctx.sourcePath,
+  );
+  const parts = Internal.splitModulePath(modulePath);
+  // Root-only by contract (see findNestedJsonValuesRecords): the entry is a
+  // direct child of the module's root record/router, so the path is one segment.
+  if (parts.length !== 1) {
+    return {
+      success: false,
+      errorMessage: `Cannot extract .jsonValues() entry at ${ctx.sourcePath}: expected a root record entry`,
+    };
+  }
+  const entryKey = parts[0];
+  const source = ctx.valModule.source;
+  if (source === null || typeof source !== "object" || Array.isArray(source)) {
+    return {
+      success: false,
+      errorMessage: `Could not get source for ${ctx.moduleFilePath}`,
+    };
+  }
+  const content = (source as Record<string, Json>)[entryKey];
+  if (content === undefined) {
+    return {
+      success: false,
+      errorMessage: `Could not find .jsonValues() entry '${entryKey}' in ${ctx.moduleFilePath}`,
+    };
+  }
+  if (!ctx.fix) {
+    return {
+      success: true,
+      fixableErrorMessage: ctx.validationError.message,
+    };
+  }
+  try {
+    extractJsonValuesEntry(
+      ctx.moduleFilePath,
+      ctx.projectRoot,
+      entryKey,
+      content,
+      ctx.service.sourceFileHandler,
+    );
+  } catch (err) {
+    return {
+      success: false,
+      errorMessage: err instanceof Error ? err.message : String(err),
+    };
+  }
+  return { success: true, appliedFix: true };
+}
+
 // Fix handler registry. `keyof:check-keys` and `router:check-route` are
 // resolved upfront by the shared resolveSchemaSourceFixes — they never reach
 // this registry, so they're excluded from the key set.
@@ -695,6 +755,7 @@ export const currentFixHandlers: Record<
   "files:check-unique-folder": handleUniqueFolderCheck,
   "images:check-all-files": handleCheckAllFiles,
   "files:check-all-files": handleCheckAllFiles,
+  "jsonValues:extract-entry": handleJsonValuesExtractEntry,
 };
 const deprecatedFixHandlers: Record<string, FixHandler> = {
   "image:replace-metadata": handleFileMetadata,
@@ -881,6 +942,22 @@ export async function* runValidation({
                 continue;
               }
 
+              if (result.appliedFix) {
+                fixedErrors += 1;
+                yield { type: "fix-applied", file, sourcePath };
+              }
+
+              if (result.fixableErrorMessage !== undefined) {
+                fileErrors += 1;
+                yield {
+                  type: "validation-fixable-error",
+                  sourcePath,
+                  message: result.fixableErrorMessage,
+                  fixable: true,
+                  ...(v.keyError ? { keyError: true } : {}),
+                };
+              }
+
               // Apply patch if needed
               if (result.shouldApplyPatch) {
                 const fixPatch = await createFixPatch(

package/src/utils/sourcePathToFileLocation.ts

@@ -2,14 +2,21 @@ import path from "path";
 import nodeFs from "fs";
 import ts from "typescript";
 import picocolors from "picocolors";
-import { Internal, type SourcePath } from "@valbuild/core";
+import { Internal, type ModulePath, type SourcePath } from "@valbuild/core";
 import {
+  createJsonEntryPathMap,
   createModulePathMap,
+  findJsonEntryFilePath,
   getModulePathRange,
   type ModulePathMap,
 } from "@valbuild/server";
 
-type CachedFile = { lines: string[]; map: ModulePathMap | undefined };
+type CachedFile = {
+  lines: string[];
+  map: ModulePathMap | undefined;
+  /** The parsed `.val.ts`, kept so a jsonValues entry's file can be located. */
+  sourceFile?: ts.SourceFile;
+};
 
 /**
  * Per-run cache mapping a moduleFilePath to its parsed source. `null` means the
@@ -129,21 +136,41 @@ function resolveRange(
   }
 
   const range = getModulePathRange(modulePath, cached.map, target);
-  if (!range) {
-    return undefined;
+  if (range) {
+    return {
+      relativeFile: moduleFilePath.replace(/^\//, ""),
+      lines: cached.lines,
+      range: clampRange(range),
+    };
   }
+  // Nothing in the `.val.ts` matches — which is the normal case for a
+  // `.jsonValues()` entry, since the value lives in its own `*.val.json` and the
+  // `.val.ts` only holds the `c.json(() => import(...))` thunk. Follow it.
+  const entryResolved = resolveJsonEntryRange(
+    moduleFilePath,
+    modulePath,
+    projectRoot,
+    cache,
+    target,
+    cached,
+  );
+  // Clamped here too: an entry's range comes from the same resolver, run against
+  // the entry's `*.val.json`, so it can be just as bad.
+  return (
+    entryResolved && {
+      ...entryResolved,
+      range: clampRange(entryResolved.range),
+    }
+  );
+}
 
-  return {
-    relativeFile: moduleFilePath.replace(/^\//, ""),
-    lines: cached.lines,
-    // Defensive: a bad range must degrade to an odd-looking frame, never a
-    // crash - the caret math below does `" ".repeat(start.character)`, which
-    // throws a RangeError on a negative count.
-    range: {
-      start: clampPosition(range.start),
-      end: clampPosition(range.end),
-    },
-  };
+/**
+ * Defensive: a bad range must degrade to an odd-looking frame, never a crash —
+ * the caret math in the code frame does `" ".repeat(start.character)`, which
+ * throws a RangeError on a negative count.
+ */
+function clampRange(range: Range): Range {
+  return { start: clampPosition(range.start), end: clampPosition(range.end) };
 }
 
 function clampPosition(position: Position): Position {
@@ -153,6 +180,99 @@ function clampPosition(position: Position): Position {
   };
 }
 
+/**
+ * Resolves the part of a source path BELOW a `.jsonValues()` entry key against
+ * the entry's backing `*.val.json`.
+ *
+ * Without this a validation error in an entry has no location at all: for a
+ * record with hundreds of entries the report would name the module and the rule
+ * but not which entry, which is barely a report.
+ */
+function resolveJsonEntryRange(
+  moduleFilePath: string,
+  modulePath: string,
+  projectRoot: string,
+  cache: SourceFileCache,
+  target: "key" | "value",
+  cachedModule: CachedFile,
+): { relativeFile: string; lines: string[]; range: Range } | undefined {
+  if (!modulePath || !cachedModule.sourceFile) {
+    return undefined;
+  }
+  let segments: string[];
+  try {
+    segments = Internal.splitModulePath(modulePath as ModulePath);
+  } catch {
+    return undefined;
+  }
+  const [entryKey, ...rest] = segments;
+  if (entryKey === undefined) {
+    return undefined;
+  }
+  const jsonFilePath = findJsonEntryFilePath(
+    moduleFilePath,
+    cachedModule.sourceFile,
+    entryKey,
+  );
+  if (!jsonFilePath) {
+    return undefined;
+  }
+  const cachedJson = getCachedJsonFile(jsonFilePath, projectRoot, cache);
+  if (!cachedJson) {
+    return undefined;
+  }
+  const relativeFile = jsonFilePath.replace(/^\//, "");
+  if (rest.length === 0) {
+    // The error is on the entry as a whole (e.g. it failed to load): point at the
+    // top of its file rather than nowhere.
+    return {
+      relativeFile,
+      lines: cachedJson.lines,
+      range: {
+        start: { line: 0, character: 0 },
+        end: { line: 0, character: 0 },
+      },
+    };
+  }
+  if (!cachedJson.map) {
+    return undefined;
+  }
+  const range = getModulePathRange(
+    rest.map((segment) => JSON.stringify(segment)).join("."),
+    cachedJson.map,
+    target,
+  );
+  if (!range) {
+    return undefined;
+  }
+  return { relativeFile, lines: cachedJson.lines, range };
+}
+
+function getCachedJsonFile(
+  jsonFilePath: string,
+  projectRoot: string,
+  cache: SourceFileCache,
+): CachedFile | null {
+  const existing = cache.get(jsonFilePath);
+  if (existing !== undefined) {
+    return existing;
+  }
+  const filePath = path.join(projectRoot, jsonFilePath);
+  let fileContent: string;
+  try {
+    fileContent = nodeFs.readFileSync(filePath, "utf-8");
+  } catch {
+    cache.set(jsonFilePath, null);
+    return null;
+  }
+  const entry: CachedFile = {
+    lines: fileContent.split(/\r?\n/),
+    map: createJsonEntryPathMap(ts.parseJsonText(filePath, fileContent)),
+  };
+  cache.set(jsonFilePath, entry);
+  return entry;
+}
+
 function getCachedFile(
   moduleFilePath: string,
   projectRoot: string,
@@ -178,6 +298,7 @@ function getCachedFile(
   const entry: CachedFile = {
     lines: fileContent.split(/\r?\n/),
     map: createModulePathMap(sourceFile),
+    sourceFile,
   };
   cache.set(moduleFilePath, entry);
   return entry;

package/tsconfig.json

@@ -7,6 +7,7 @@
     "module": "esnext",
     "moduleResolution": "node",
     "skipLibCheck": true,
-    "target": "ESNext"
+    "target": "ESNext",
+    "resolveJsonModule": true
   }
 }