@valbuild/language-server 0.108.3 → 0.108.5

package/dist/declarations/src/codeActions.d.ts

@@ -7,13 +7,23 @@ import type { ValModuleContent } from "./ValProject.js";
 import { minimalTextEdit } from "./textEdit.js";
 export { minimalTextEdit };
 export declare function isLocalFix(fix: string): fix is ValidationFix;
-export declare function createValCodeActions({ document, diagnostics, content, valRoot, moduleFilePath, remoteHost, }: {
+export declare function createValCodeActions({ document, diagnostics, content, valRoot, moduleFilePath, read, remoteHost, }: {
     document: TextDocument;
     diagnostics: Diagnostic[];
     content: ValModuleContent;
     valRoot: string;
-    /** Needed to offer the remote fixes, which run as commands. */
+    /**
+     * Needed to offer the remote fixes, which run as commands -- and to fix a
+     * `.jsonValues()` entry, whose content is in a file this document only
+     * references.
+     */
     moduleFilePath?: ModuleFilePath;
+    /**
+     * Reads an open buffer for a path. A fix that edits another file must see that
+     * file as the editor has it, or the edit's ranges are computed against text
+     * the editor is not showing.
+     */
+    read?: (fsPath: string) => string | undefined;
     remoteHost?: string;
 }): Promise<CodeAction[]>;
 /**

package/dist/declarations/src/uri.d.ts

@@ -1,5 +1,6 @@
 import type { ModuleFilePath } from "@valbuild/core";
 export declare function isValModuleUri(uri: string): boolean;
+export declare function isValJsonEntryUri(uri: string): boolean;
 /**
  * `file:///a/b.val.ts` -> `/a/b.val.ts`
  *

package/dist/valbuild-language-server.cjs.dev.js

@@ -14,6 +14,7 @@ var crypto = require('crypto');
 var node_module = require('node:module');
 var internal = require('@valbuild/shared/internal');
 var fp = require('@valbuild/core/fp');
+var patch = require('@valbuild/core/patch');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { 'default': e }; }
 
@@ -1148,10 +1149,46 @@ preferChild) {
     }
   }
   const range = getModulePathRange(modulePath, modulePathMap);
-  return range ? {
-    start: range.start,
-    end: range.end
-  } : FALLBACK_RANGE;
+  if (range) {
+    return {
+      start: range.start,
+      end: range.end
+    };
+  }
+  return longestResolvedPrefixRange(modulePath, modulePathMap) ?? FALLBACK_RANGE;
+}
+
+/**
+ * The range of the longest prefix of `modulePath` this module's own text knows
+ * about.
+ *
+ * `.jsonValues()` is why this exists. An entry's value lives in a separate
+ * `*.val.json`, so the `.val.ts` contains the entry KEY and nothing below it,
+ * and every error inside an entry resolved to nothing at all -- landing on
+ * FALLBACK_RANGE, line 1. For a record with hundreds of entries that is hundreds
+ * of diagnostics stacked on the first line, none of them naming an entry.
+ *
+ * The entry key is not where the offending value is -- that is in the other file
+ * -- but it is the closest place in THIS file, and it is where the quick fix is
+ * offered from.
+ */
+function longestResolvedPrefixRange(modulePath, modulePathMap) {
+  let segments;
+  try {
+    segments = core.Internal.splitModulePath(modulePath);
+  } catch {
+    return undefined;
+  }
+  for (let length = segments.length - 1; length > 0; length--) {
+    const range = getModulePathRange(segments.slice(0, length).map(segment => JSON.stringify(segment)).join("."), modulePathMap);
+    if (range) {
+      return {
+        start: range.start,
+        end: range.end
+      };
+    }
+  }
+  return undefined;
 }
 
 /**
@@ -1794,9 +1831,19 @@ const FILE_URI_RE = /^file:\/\/([^/?#]*)([^?#]*)/i;
 
 /** A `/c:/...` prefix, i.e. a Windows drive letter as it appears in a URI. */
 const URI_DRIVE_LETTER_RE = /^\/([a-zA-Z]:)(\/|$)/;
+
+/**
+ * Matches the `*.val.json` files that hold `.jsonValues()` entry content. Not a
+ * Val module: nothing validates one on its own, but editing it changes what a
+ * module validates to, so the server has to notice.
+ */
+const VAL_JSON_ENTRY_RE = /\.val\.json$/;
 function isValModuleUri(uri) {
   return VAL_MODULE_RE.test(uri);
 }
+function isValJsonEntryUri(uri) {
+  return VAL_JSON_ENTRY_RE.test(uri);
+}
 
 /**
  * `decodeURIComponent` throws on malformed escapes (`%zz`). A client that sends
@@ -1862,6 +1909,144 @@ function toModuleFilePath(valRoot, uri) {
   return `/${relative.split(path__default["default"].sep).join("/")}`;
 }
 
+const jsonOps = new patch.JSONOps();
+
+/**
+ * Turning a fix patch into an edit when the value it fixes is NOT in the
+ * `.val.ts` the diagnostic was reported on.
+ *
+ * A `.jsonValues()` record keeps each entry's value in its own `*.val.json`; the
+ * `.val.ts` holds `c.json(() => import("./x.val.json"))` and nothing below it.
+ * So a fix for, say, an `s.image()` inside an entry produces a patch whose path
+ * starts at the module root (`["/jobb/student", "pageImage", "width"]`) but
+ * whose target lives in another file entirely.
+ *
+ * Applying such a patch to the `.val.ts` cannot work: the walk reaches the
+ * `c.json(...)` call expression and `TSOps` refuses it ("Expression must be a
+ * literal"). That refusal is why an editor silently offered no quick fix at all
+ * for anything inside an entry — `computeFixEdit` saw an error result and
+ * dropped the action.
+ *
+ * The routing here is the same one the Studio's publish and `val validate --fix`
+ * use — {@link classifyJsonValuesOp} to find the entry, {@link rebaseContentOp}
+ * to drop the entry-key prefix — so all three write the same file the same way.
+ * What is specific to the editor is only the last step: the result comes back as
+ * a `TextEdit` against the entry's document rather than as a write to disk, so
+ * the edit goes through the editor's undo stack and respects an unsaved buffer.
+ */
+
+function jsonEntryEditFor({
+  patch: patch$1,
+  schema,
+  moduleFilePath,
+  valTsText,
+  valRoot,
+  read
+}) {
+  if (!schema) {
+    return undefined;
+  }
+  const entry = entryOpsOf(patch$1, schema);
+  if (!entry) {
+    return undefined;
+  }
+  const jsonFilePath = server.findJsonEntryFilePath(moduleFilePath, ts__default["default"].createSourceFile(moduleFilePath, valTsText, ts__default["default"].ScriptTarget.ES2020), entry.entryKey);
+  if (!jsonFilePath) {
+    return undefined;
+  }
+  const absolutePath = path__default["default"].join(valRoot, jsonFilePath);
+  const before = read?.(absolutePath) ?? readFile(absolutePath);
+  if (before === undefined) {
+    return undefined;
+  }
+  let content;
+  try {
+    content = JSON.parse(before);
+  } catch {
+    // A malformed entry file is already reported as a load error; offering an
+    // edit computed from a guess at its contents would be worse than offering
+    // nothing.
+    return undefined;
+  }
+  for (const op of entry.ops) {
+    // Root-only, like the rest of the `.jsonValues()` machinery, so the prefix
+    // to drop is exactly the entry key.
+    const rebased = server.rebaseContentOp(op, 1);
+    if (fp.result.isErr(rebased)) {
+      return undefined;
+    }
+    const applied = patch.applyPatch(patch.deepClone(content), jsonOps, [rebased.value]);
+    if (fp.result.isErr(applied)) {
+      return undefined;
+    }
+    content = applied.value;
+  }
+  // Re-serialising the whole value and diffing it is what keeps this honest:
+  // the alternative is editing JSON text by hand, and the fix would then differ
+  // from what the CLI writes. `minimalTextEdit` narrows the result to the region
+  // that actually changed, so a two-space-indented file (what prettier and the
+  // CLI both produce) yields an edit covering the changed properties and no
+  // more. A file indented differently gets a correct but larger edit.
+  const after = JSON.stringify(content, null, 2) + (before.endsWith("\n") ? "\n" : "");
+  const uri = pathToUri(absolutePath);
+  const edit = minimalTextEdit(before, after, vscodeLanguageserverTextdocument.TextDocument.create(uri, "json", 0, before));
+  return edit && {
+    uri,
+    edit
+  };
+}
+
+/**
+ * The ops of `patch`, if every one of them edits the content of ONE
+ * `.jsonValues()` entry. `undefined` for anything else — an ordinary module, a
+ * patch that also touches the `.val.ts`, or one that adds or removes a whole
+ * entry — because those either belong on the `.val.ts` (the caller's existing
+ * path) or need both files written at once, which a single `TextEdit` cannot do.
+ */
+function entryOpsOf(patch, schema) {
+  let entryKey;
+  const ops = [];
+  for (const op of patch) {
+    const cls = server.classifyJsonValuesOp(schema, op.path);
+    if (cls.kind !== "entry") {
+      return undefined;
+    }
+    // Nested `.jsonValues()` is rejected as a module error long before a fix is
+    // offered; treat it as out of scope rather than writing to a guessed file.
+    if (cls.recordPath.length > 0 || cls.subPath.length === 0) {
+      return undefined;
+    }
+    // `move` and `copy` carry a second path, and `rebaseContentOp` slices `from`
+    // by the same prefix as `path` -- so an op reaching outside this entry would
+    // have its source silently reinterpreted as a path inside this entry's file.
+    if (op.op === "move" || op.op === "copy") {
+      const fromCls = server.classifyJsonValuesOp(schema, op.from);
+      if (fromCls.kind !== "entry" || fromCls.entryKey !== cls.entryKey) {
+        return undefined;
+      }
+    }
+    if (entryKey !== undefined && entryKey !== cls.entryKey) {
+      return undefined;
+    }
+    entryKey = cls.entryKey;
+    ops.push(op);
+  }
+  if (entryKey === undefined || ops.length === 0) {
+    return undefined;
+  }
+  return {
+    entryKey,
+    ops
+  };
+}
+function readFile(filePath) {
+  try {
+    return fs__default["default"].readFileSync(filePath, "utf8");
+  } catch {
+    return undefined;
+  }
+}
+
 /**
  * Quick fixes, built by running Val's own fix machinery.
  *
@@ -1919,6 +2104,7 @@ async function createValCodeActions({
   content,
   valRoot,
   moduleFilePath,
+  read,
   remoteHost = process.env.VAL_REMOTE_HOST || core.DEFAULT_VAL_REMOTE_HOST
 }) {
   const actions = [];
@@ -1960,7 +2146,7 @@ async function createValCodeActions({
       if (!isLocalFix(fix)) {
         continue;
       }
-      const edit = await computeFixEdit({
+      const fixEdit = await computeFixEdit({
         document,
         // A gallery check is reported on the entry but fixed against the record
         // that contains it; everything else fixes where it is reported.
@@ -1974,14 +2160,20 @@ async function createValCodeActions({
         },
         content,
         valRoot,
+        moduleFilePath,
+        read,
         remoteHost
       });
-      if (!edit) {
+      if (!fixEdit) {
         continue;
       }
-      actions.push(vscodeLanguageserver.CodeAction.create(FIX_TITLES[fix] ?? `Val: ${fix}`, {
+      actions.push(vscodeLanguageserver.CodeAction.create(FIX_TITLES[fix] ?? `Val: ${fix}`,
+      // Not always `document.uri`: a fix inside a `.jsonValues()` entry
+      // edits the entry's own `*.val.json`, which is a different file from
+      // the one the diagnostic is reported on.
+      {
         changes: {
-          [document.uri]: [edit]
+          [fixEdit.uri]: [fixEdit.edit]
         }
       }, vscodeLanguageserver.CodeActionKind.QuickFix));
     }
@@ -1994,6 +2186,8 @@ async function computeFixEdit({
   validationError,
   content,
   valRoot,
+  moduleFilePath,
+  read,
   remoteHost
 }) {
   let fixed;
@@ -2012,11 +2206,32 @@ async function computeFixEdit({
     return undefined;
   }
   const before = document.getText();
+  // The value may not be in this file at all. A `.jsonValues()` entry's content
+  // lives in its own `*.val.json`, and applying the patch to the `.val.ts` would
+  // walk into the `c.json(...)` thunk and fail -- which is exactly why no quick
+  // fix was offered inside an entry.
+  if (moduleFilePath) {
+    const entryEdit = jsonEntryEditFor({
+      patch: fixed.patch,
+      schema: content.schema,
+      moduleFilePath,
+      valTsText: before,
+      valRoot,
+      read
+    });
+    if (entryEdit) {
+      return entryEdit;
+    }
+  }
   const patched = server.patchSourceFile(before, fixed.patch);
   if (fp.result.isErr(patched)) {
     return undefined;
   }
-  return minimalTextEdit(before, patched.value.text, document);
+  const edit = minimalTextEdit(before, patched.value.text, document);
+  return edit && {
+    uri: document.uri,
+    edit
+  };
 }
 
 /**
@@ -3468,6 +3683,12 @@ function createValLanguageServer(connection) {
     void connection.client.register(vscodeLanguageserver.DidChangeWatchedFilesNotification.type, {
       watchers: [{
         globPattern: "**/*.val.{ts,js}"
+      },
+      // A `.jsonValues()` entry's content is here, not in the `.val.ts`, so
+      // this is the only thing that says an entry changed -- including when
+      // the change is a quick fix the editor just applied.
+      {
+        globPattern: "**/*.val.json"
       }, {
         globPattern: "**/val.modules.{ts,js}"
       }, {
@@ -3575,7 +3796,8 @@ function createValLanguageServer(connection) {
         diagnostics: params.context.diagnostics,
         content: result.content,
         valRoot: project.valRoot,
-        moduleFilePath
+        moduleFilePath,
+        read: readOpenDocument
       })));
       return actions;
     } catch (e) {
@@ -3592,7 +3814,10 @@ function createValLanguageServer(connection) {
   documents.onDidChangeContent(({
     document
   }) => {
-    if (PROJECT_WIDE_FILE_RE.test(uriToPath(document.uri))) {
+    if (PROJECT_WIDE_FILE_RE.test(uriToPath(document.uri)) ||
+    // Same reason as in the watched-files handler: an open, unsaved entry file
+    // is read through the editor overlay, but only a fresh Service sees it.
+    isValJsonEntryUri(document.uri)) {
       // A project-wide fact changed, so every module's cached result is stale --
       // not just this file's. `invalidate()` with no argument clears the content
       // cache too, which the per-module fingerprint check would not.
@@ -3634,6 +3859,13 @@ function createValLanguageServer(connection) {
         projectWide = true;
         continue;
       }
+      // An entry file has no module of its own to invalidate: which module reads
+      // it is recorded in a `.val.ts` import specifier, and the parsed JSON is
+      // cached inside the Service, which only a project-wide invalidate discards.
+      if (isValJsonEntryUri(change.uri)) {
+        projectWide = true;
+        continue;
+      }
       // A file appearing or vanishing under the files directory changes what a
       // media path may complete to.
       publicFiles?.invalidate();
@@ -3682,6 +3914,19 @@ function createValLanguageServer(connection) {
       uri: document.uri,
       diagnostics: []
     });
+    // Closing an entry file REMOVES an overlay: whatever the buffer said stops
+    // being what the module reads, and the modules that read it are still open,
+    // still showing diagnostics computed from a buffer that no longer exists.
+    // (Opening one needs no case of its own -- `TextDocuments` fires
+    // onDidChangeContent for a didOpen too, which the handler above catches.)
+    if (isValJsonEntryUri(document.uri)) {
+      project?.invalidate();
+      for (const open of documents.all()) {
+        if (isValModuleUri(open.uri)) {
+          scheduleValidation(open.uri);
+        }
+      }
+    }
   });
   connection.onShutdown(() => {
     for (const timer of pending.values()) {

package/dist/valbuild-language-server.cjs.prod.js

@@ -14,6 +14,7 @@ var crypto = require('crypto');
 var node_module = require('node:module');
 var internal = require('@valbuild/shared/internal');
 var fp = require('@valbuild/core/fp');
+var patch = require('@valbuild/core/patch');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { 'default': e }; }
 
@@ -1148,10 +1149,46 @@ preferChild) {
     }
   }
   const range = getModulePathRange(modulePath, modulePathMap);
-  return range ? {
-    start: range.start,
-    end: range.end
-  } : FALLBACK_RANGE;
+  if (range) {
+    return {
+      start: range.start,
+      end: range.end
+    };
+  }
+  return longestResolvedPrefixRange(modulePath, modulePathMap) ?? FALLBACK_RANGE;
+}
+
+/**
+ * The range of the longest prefix of `modulePath` this module's own text knows
+ * about.
+ *
+ * `.jsonValues()` is why this exists. An entry's value lives in a separate
+ * `*.val.json`, so the `.val.ts` contains the entry KEY and nothing below it,
+ * and every error inside an entry resolved to nothing at all -- landing on
+ * FALLBACK_RANGE, line 1. For a record with hundreds of entries that is hundreds
+ * of diagnostics stacked on the first line, none of them naming an entry.
+ *
+ * The entry key is not where the offending value is -- that is in the other file
+ * -- but it is the closest place in THIS file, and it is where the quick fix is
+ * offered from.
+ */
+function longestResolvedPrefixRange(modulePath, modulePathMap) {
+  let segments;
+  try {
+    segments = core.Internal.splitModulePath(modulePath);
+  } catch {
+    return undefined;
+  }
+  for (let length = segments.length - 1; length > 0; length--) {
+    const range = getModulePathRange(segments.slice(0, length).map(segment => JSON.stringify(segment)).join("."), modulePathMap);
+    if (range) {
+      return {
+        start: range.start,
+        end: range.end
+      };
+    }
+  }
+  return undefined;
 }
 
 /**
@@ -1794,9 +1831,19 @@ const FILE_URI_RE = /^file:\/\/([^/?#]*)([^?#]*)/i;
 
 /** A `/c:/...` prefix, i.e. a Windows drive letter as it appears in a URI. */
 const URI_DRIVE_LETTER_RE = /^\/([a-zA-Z]:)(\/|$)/;
+
+/**
+ * Matches the `*.val.json` files that hold `.jsonValues()` entry content. Not a
+ * Val module: nothing validates one on its own, but editing it changes what a
+ * module validates to, so the server has to notice.
+ */
+const VAL_JSON_ENTRY_RE = /\.val\.json$/;
 function isValModuleUri(uri) {
   return VAL_MODULE_RE.test(uri);
 }
+function isValJsonEntryUri(uri) {
+  return VAL_JSON_ENTRY_RE.test(uri);
+}
 
 /**
  * `decodeURIComponent` throws on malformed escapes (`%zz`). A client that sends
@@ -1862,6 +1909,144 @@ function toModuleFilePath(valRoot, uri) {
   return `/${relative.split(path__default["default"].sep).join("/")}`;
 }
 
+const jsonOps = new patch.JSONOps();
+
+/**
+ * Turning a fix patch into an edit when the value it fixes is NOT in the
+ * `.val.ts` the diagnostic was reported on.
+ *
+ * A `.jsonValues()` record keeps each entry's value in its own `*.val.json`; the
+ * `.val.ts` holds `c.json(() => import("./x.val.json"))` and nothing below it.
+ * So a fix for, say, an `s.image()` inside an entry produces a patch whose path
+ * starts at the module root (`["/jobb/student", "pageImage", "width"]`) but
+ * whose target lives in another file entirely.
+ *
+ * Applying such a patch to the `.val.ts` cannot work: the walk reaches the
+ * `c.json(...)` call expression and `TSOps` refuses it ("Expression must be a
+ * literal"). That refusal is why an editor silently offered no quick fix at all
+ * for anything inside an entry — `computeFixEdit` saw an error result and
+ * dropped the action.
+ *
+ * The routing here is the same one the Studio's publish and `val validate --fix`
+ * use — {@link classifyJsonValuesOp} to find the entry, {@link rebaseContentOp}
+ * to drop the entry-key prefix — so all three write the same file the same way.
+ * What is specific to the editor is only the last step: the result comes back as
+ * a `TextEdit` against the entry's document rather than as a write to disk, so
+ * the edit goes through the editor's undo stack and respects an unsaved buffer.
+ */
+
+function jsonEntryEditFor({
+  patch: patch$1,
+  schema,
+  moduleFilePath,
+  valTsText,
+  valRoot,
+  read
+}) {
+  if (!schema) {
+    return undefined;
+  }
+  const entry = entryOpsOf(patch$1, schema);
+  if (!entry) {
+    return undefined;
+  }
+  const jsonFilePath = server.findJsonEntryFilePath(moduleFilePath, ts__default["default"].createSourceFile(moduleFilePath, valTsText, ts__default["default"].ScriptTarget.ES2020), entry.entryKey);
+  if (!jsonFilePath) {
+    return undefined;
+  }
+  const absolutePath = path__default["default"].join(valRoot, jsonFilePath);
+  const before = read?.(absolutePath) ?? readFile(absolutePath);
+  if (before === undefined) {
+    return undefined;
+  }
+  let content;
+  try {
+    content = JSON.parse(before);
+  } catch {
+    // A malformed entry file is already reported as a load error; offering an
+    // edit computed from a guess at its contents would be worse than offering
+    // nothing.
+    return undefined;
+  }
+  for (const op of entry.ops) {
+    // Root-only, like the rest of the `.jsonValues()` machinery, so the prefix
+    // to drop is exactly the entry key.
+    const rebased = server.rebaseContentOp(op, 1);
+    if (fp.result.isErr(rebased)) {
+      return undefined;
+    }
+    const applied = patch.applyPatch(patch.deepClone(content), jsonOps, [rebased.value]);
+    if (fp.result.isErr(applied)) {
+      return undefined;
+    }
+    content = applied.value;
+  }
+  // Re-serialising the whole value and diffing it is what keeps this honest:
+  // the alternative is editing JSON text by hand, and the fix would then differ
+  // from what the CLI writes. `minimalTextEdit` narrows the result to the region
+  // that actually changed, so a two-space-indented file (what prettier and the
+  // CLI both produce) yields an edit covering the changed properties and no
+  // more. A file indented differently gets a correct but larger edit.
+  const after = JSON.stringify(content, null, 2) + (before.endsWith("\n") ? "\n" : "");
+  const uri = pathToUri(absolutePath);
+  const edit = minimalTextEdit(before, after, vscodeLanguageserverTextdocument.TextDocument.create(uri, "json", 0, before));
+  return edit && {
+    uri,
+    edit
+  };
+}
+
+/**
+ * The ops of `patch`, if every one of them edits the content of ONE
+ * `.jsonValues()` entry. `undefined` for anything else — an ordinary module, a
+ * patch that also touches the `.val.ts`, or one that adds or removes a whole
+ * entry — because those either belong on the `.val.ts` (the caller's existing
+ * path) or need both files written at once, which a single `TextEdit` cannot do.
+ */
+function entryOpsOf(patch, schema) {
+  let entryKey;
+  const ops = [];
+  for (const op of patch) {
+    const cls = server.classifyJsonValuesOp(schema, op.path);
+    if (cls.kind !== "entry") {
+      return undefined;
+    }
+    // Nested `.jsonValues()` is rejected as a module error long before a fix is
+    // offered; treat it as out of scope rather than writing to a guessed file.
+    if (cls.recordPath.length > 0 || cls.subPath.length === 0) {
+      return undefined;
+    }
+    // `move` and `copy` carry a second path, and `rebaseContentOp` slices `from`
+    // by the same prefix as `path` -- so an op reaching outside this entry would
+    // have its source silently reinterpreted as a path inside this entry's file.
+    if (op.op === "move" || op.op === "copy") {
+      const fromCls = server.classifyJsonValuesOp(schema, op.from);
+      if (fromCls.kind !== "entry" || fromCls.entryKey !== cls.entryKey) {
+        return undefined;
+      }
+    }
+    if (entryKey !== undefined && entryKey !== cls.entryKey) {
+      return undefined;
+    }
+    entryKey = cls.entryKey;
+    ops.push(op);
+  }
+  if (entryKey === undefined || ops.length === 0) {
+    return undefined;
+  }
+  return {
+    entryKey,
+    ops
+  };
+}
+function readFile(filePath) {
+  try {
+    return fs__default["default"].readFileSync(filePath, "utf8");
+  } catch {
+    return undefined;
+  }
+}
+
 /**
  * Quick fixes, built by running Val's own fix machinery.
  *
@@ -1919,6 +2104,7 @@ async function createValCodeActions({
   content,
   valRoot,
   moduleFilePath,
+  read,
   remoteHost = process.env.VAL_REMOTE_HOST || core.DEFAULT_VAL_REMOTE_HOST
 }) {
   const actions = [];
@@ -1960,7 +2146,7 @@ async function createValCodeActions({
       if (!isLocalFix(fix)) {
         continue;
       }
-      const edit = await computeFixEdit({
+      const fixEdit = await computeFixEdit({
         document,
         // A gallery check is reported on the entry but fixed against the record
         // that contains it; everything else fixes where it is reported.
@@ -1974,14 +2160,20 @@ async function createValCodeActions({
         },
         content,
         valRoot,
+        moduleFilePath,
+        read,
         remoteHost
       });
-      if (!edit) {
+      if (!fixEdit) {
         continue;
       }
-      actions.push(vscodeLanguageserver.CodeAction.create(FIX_TITLES[fix] ?? `Val: ${fix}`, {
+      actions.push(vscodeLanguageserver.CodeAction.create(FIX_TITLES[fix] ?? `Val: ${fix}`,
+      // Not always `document.uri`: a fix inside a `.jsonValues()` entry
+      // edits the entry's own `*.val.json`, which is a different file from
+      // the one the diagnostic is reported on.
+      {
         changes: {
-          [document.uri]: [edit]
+          [fixEdit.uri]: [fixEdit.edit]
         }
       }, vscodeLanguageserver.CodeActionKind.QuickFix));
     }
@@ -1994,6 +2186,8 @@ async function computeFixEdit({
   validationError,
   content,
   valRoot,
+  moduleFilePath,
+  read,
   remoteHost
 }) {
   let fixed;
@@ -2012,11 +2206,32 @@ async function computeFixEdit({
     return undefined;
   }
   const before = document.getText();
+  // The value may not be in this file at all. A `.jsonValues()` entry's content
+  // lives in its own `*.val.json`, and applying the patch to the `.val.ts` would
+  // walk into the `c.json(...)` thunk and fail -- which is exactly why no quick
+  // fix was offered inside an entry.
+  if (moduleFilePath) {
+    const entryEdit = jsonEntryEditFor({
+      patch: fixed.patch,
+      schema: content.schema,
+      moduleFilePath,
+      valTsText: before,
+      valRoot,
+      read
+    });
+    if (entryEdit) {
+      return entryEdit;
+    }
+  }
   const patched = server.patchSourceFile(before, fixed.patch);
   if (fp.result.isErr(patched)) {
     return undefined;
   }
-  return minimalTextEdit(before, patched.value.text, document);
+  const edit = minimalTextEdit(before, patched.value.text, document);
+  return edit && {
+    uri: document.uri,
+    edit
+  };
 }
 
 /**
@@ -3468,6 +3683,12 @@ function createValLanguageServer(connection) {
     void connection.client.register(vscodeLanguageserver.DidChangeWatchedFilesNotification.type, {
       watchers: [{
         globPattern: "**/*.val.{ts,js}"
+      },
+      // A `.jsonValues()` entry's content is here, not in the `.val.ts`, so
+      // this is the only thing that says an entry changed -- including when
+      // the change is a quick fix the editor just applied.
+      {
+        globPattern: "**/*.val.json"
       }, {
         globPattern: "**/val.modules.{ts,js}"
       }, {
@@ -3575,7 +3796,8 @@ function createValLanguageServer(connection) {
         diagnostics: params.context.diagnostics,
         content: result.content,
         valRoot: project.valRoot,
-        moduleFilePath
+        moduleFilePath,
+        read: readOpenDocument
       })));
       return actions;
     } catch (e) {
@@ -3592,7 +3814,10 @@ function createValLanguageServer(connection) {
   documents.onDidChangeContent(({
     document
   }) => {
-    if (PROJECT_WIDE_FILE_RE.test(uriToPath(document.uri))) {
+    if (PROJECT_WIDE_FILE_RE.test(uriToPath(document.uri)) ||
+    // Same reason as in the watched-files handler: an open, unsaved entry file
+    // is read through the editor overlay, but only a fresh Service sees it.
+    isValJsonEntryUri(document.uri)) {
       // A project-wide fact changed, so every module's cached result is stale --
       // not just this file's. `invalidate()` with no argument clears the content
       // cache too, which the per-module fingerprint check would not.
@@ -3634,6 +3859,13 @@ function createValLanguageServer(connection) {
         projectWide = true;
         continue;
       }
+      // An entry file has no module of its own to invalidate: which module reads
+      // it is recorded in a `.val.ts` import specifier, and the parsed JSON is
+      // cached inside the Service, which only a project-wide invalidate discards.
+      if (isValJsonEntryUri(change.uri)) {
+        projectWide = true;
+        continue;
+      }
       // A file appearing or vanishing under the files directory changes what a
       // media path may complete to.
       publicFiles?.invalidate();
@@ -3682,6 +3914,19 @@ function createValLanguageServer(connection) {
       uri: document.uri,
       diagnostics: []
     });
+    // Closing an entry file REMOVES an overlay: whatever the buffer said stops
+    // being what the module reads, and the modules that read it are still open,
+    // still showing diagnostics computed from a buffer that no longer exists.
+    // (Opening one needs no case of its own -- `TextDocuments` fires
+    // onDidChangeContent for a didOpen too, which the handler above catches.)
+    if (isValJsonEntryUri(document.uri)) {
+      project?.invalidate();
+      for (const open of documents.all()) {
+        if (isValModuleUri(open.uri)) {
+          scheduleValidation(open.uri);
+        }
+      }
+    }
   });
   connection.onShutdown(() => {
     for (const timer of pending.values()) {

package/dist/valbuild-language-server.esm.js

@@ -2,7 +2,7 @@ import fs from 'fs';
 import path from 'path';
 import ts from 'typescript';
 import { Internal, DEFAULT_VAL_REMOTE_HOST, DEFAULT_CONTENT_HOST } from '@valbuild/core';
-import { fixHandlers, createService, analyzeValModule, parsePersonalAccessTokenFile, getPersonalAccessTokenPath, startValLogin, awaitValLoginConfirmation, persistPersonalAccessToken, ValLoginError, findAndEvalValConfigFile, createFixPatch, patchSourceFile, getSettings, uploadRemoteFile, extractImageMetadata, extractFileMetadata } from '@valbuild/server';
+import { fixHandlers, createService, analyzeValModule, parsePersonalAccessTokenFile, getPersonalAccessTokenPath, startValLogin, awaitValLoginConfirmation, persistPersonalAccessToken, ValLoginError, findAndEvalValConfigFile, createFixPatch, patchSourceFile, getSettings, uploadRemoteFile, findJsonEntryFilePath, rebaseContentOp, classifyJsonValuesOp, extractImageMetadata, extractFileMetadata } from '@valbuild/server';
 import { DiagnosticSeverity, ShowDocumentRequest, ApplyWorkspaceEditRequest, CodeActionKind, CodeAction, MarkupContent, CompletionItemKind, DidChangeWatchedFilesNotification } from 'vscode-languageserver';
 import { TextDocuments, TextDocumentSyncKind, createConnection, ProposedFeatures } from 'vscode-languageserver/node';
 import { TextDocument } from 'vscode-languageserver-textdocument';
@@ -10,6 +10,7 @@ import crypto from 'crypto';
 import { createRequire } from 'node:module';
 import { resolveSchemaSourceFixes, getRoutesWithModulePaths } from '@valbuild/shared/internal';
 import { result } from '@valbuild/core/fp';
+import { JSONOps, applyPatch, deepClone } from '@valbuild/core/patch';
 
 /**
  * The Val language server protocol.
@@ -1137,10 +1138,46 @@ preferChild) {
     }
   }
   const range = getModulePathRange(modulePath, modulePathMap);
-  return range ? {
-    start: range.start,
-    end: range.end
-  } : FALLBACK_RANGE;
+  if (range) {
+    return {
+      start: range.start,
+      end: range.end
+    };
+  }
+  return longestResolvedPrefixRange(modulePath, modulePathMap) ?? FALLBACK_RANGE;
+}
+
+/**
+ * The range of the longest prefix of `modulePath` this module's own text knows
+ * about.
+ *
+ * `.jsonValues()` is why this exists. An entry's value lives in a separate
+ * `*.val.json`, so the `.val.ts` contains the entry KEY and nothing below it,
+ * and every error inside an entry resolved to nothing at all -- landing on
+ * FALLBACK_RANGE, line 1. For a record with hundreds of entries that is hundreds
+ * of diagnostics stacked on the first line, none of them naming an entry.
+ *
+ * The entry key is not where the offending value is -- that is in the other file
+ * -- but it is the closest place in THIS file, and it is where the quick fix is
+ * offered from.
+ */
+function longestResolvedPrefixRange(modulePath, modulePathMap) {
+  let segments;
+  try {
+    segments = Internal.splitModulePath(modulePath);
+  } catch {
+    return undefined;
+  }
+  for (let length = segments.length - 1; length > 0; length--) {
+    const range = getModulePathRange(segments.slice(0, length).map(segment => JSON.stringify(segment)).join("."), modulePathMap);
+    if (range) {
+      return {
+        start: range.start,
+        end: range.end
+      };
+    }
+  }
+  return undefined;
 }
 
 /**
@@ -1783,9 +1820,19 @@ const FILE_URI_RE = /^file:\/\/([^/?#]*)([^?#]*)/i;
 
 /** A `/c:/...` prefix, i.e. a Windows drive letter as it appears in a URI. */
 const URI_DRIVE_LETTER_RE = /^\/([a-zA-Z]:)(\/|$)/;
+
+/**
+ * Matches the `*.val.json` files that hold `.jsonValues()` entry content. Not a
+ * Val module: nothing validates one on its own, but editing it changes what a
+ * module validates to, so the server has to notice.
+ */
+const VAL_JSON_ENTRY_RE = /\.val\.json$/;
 function isValModuleUri(uri) {
   return VAL_MODULE_RE.test(uri);
 }
+function isValJsonEntryUri(uri) {
+  return VAL_JSON_ENTRY_RE.test(uri);
+}
 
 /**
  * `decodeURIComponent` throws on malformed escapes (`%zz`). A client that sends
@@ -1851,6 +1898,144 @@ function toModuleFilePath(valRoot, uri) {
   return `/${relative.split(path.sep).join("/")}`;
 }
 
+const jsonOps = new JSONOps();
+
+/**
+ * Turning a fix patch into an edit when the value it fixes is NOT in the
+ * `.val.ts` the diagnostic was reported on.
+ *
+ * A `.jsonValues()` record keeps each entry's value in its own `*.val.json`; the
+ * `.val.ts` holds `c.json(() => import("./x.val.json"))` and nothing below it.
+ * So a fix for, say, an `s.image()` inside an entry produces a patch whose path
+ * starts at the module root (`["/jobb/student", "pageImage", "width"]`) but
+ * whose target lives in another file entirely.
+ *
+ * Applying such a patch to the `.val.ts` cannot work: the walk reaches the
+ * `c.json(...)` call expression and `TSOps` refuses it ("Expression must be a
+ * literal"). That refusal is why an editor silently offered no quick fix at all
+ * for anything inside an entry — `computeFixEdit` saw an error result and
+ * dropped the action.
+ *
+ * The routing here is the same one the Studio's publish and `val validate --fix`
+ * use — {@link classifyJsonValuesOp} to find the entry, {@link rebaseContentOp}
+ * to drop the entry-key prefix — so all three write the same file the same way.
+ * What is specific to the editor is only the last step: the result comes back as
+ * a `TextEdit` against the entry's document rather than as a write to disk, so
+ * the edit goes through the editor's undo stack and respects an unsaved buffer.
+ */
+
+function jsonEntryEditFor({
+  patch,
+  schema,
+  moduleFilePath,
+  valTsText,
+  valRoot,
+  read
+}) {
+  if (!schema) {
+    return undefined;
+  }
+  const entry = entryOpsOf(patch, schema);
+  if (!entry) {
+    return undefined;
+  }
+  const jsonFilePath = findJsonEntryFilePath(moduleFilePath, ts.createSourceFile(moduleFilePath, valTsText, ts.ScriptTarget.ES2020), entry.entryKey);
+  if (!jsonFilePath) {
+    return undefined;
+  }
+  const absolutePath = path.join(valRoot, jsonFilePath);
+  const before = read?.(absolutePath) ?? readFile(absolutePath);
+  if (before === undefined) {
+    return undefined;
+  }
+  let content;
+  try {
+    content = JSON.parse(before);
+  } catch {
+    // A malformed entry file is already reported as a load error; offering an
+    // edit computed from a guess at its contents would be worse than offering
+    // nothing.
+    return undefined;
+  }
+  for (const op of entry.ops) {
+    // Root-only, like the rest of the `.jsonValues()` machinery, so the prefix
+    // to drop is exactly the entry key.
+    const rebased = rebaseContentOp(op, 1);
+    if (result.isErr(rebased)) {
+      return undefined;
+    }
+    const applied = applyPatch(deepClone(content), jsonOps, [rebased.value]);
+    if (result.isErr(applied)) {
+      return undefined;
+    }
+    content = applied.value;
+  }
+  // Re-serialising the whole value and diffing it is what keeps this honest:
+  // the alternative is editing JSON text by hand, and the fix would then differ
+  // from what the CLI writes. `minimalTextEdit` narrows the result to the region
+  // that actually changed, so a two-space-indented file (what prettier and the
+  // CLI both produce) yields an edit covering the changed properties and no
+  // more. A file indented differently gets a correct but larger edit.
+  const after = JSON.stringify(content, null, 2) + (before.endsWith("\n") ? "\n" : "");
+  const uri = pathToUri(absolutePath);
+  const edit = minimalTextEdit(before, after, TextDocument.create(uri, "json", 0, before));
+  return edit && {
+    uri,
+    edit
+  };
+}
+
+/**
+ * The ops of `patch`, if every one of them edits the content of ONE
+ * `.jsonValues()` entry. `undefined` for anything else — an ordinary module, a
+ * patch that also touches the `.val.ts`, or one that adds or removes a whole
+ * entry — because those either belong on the `.val.ts` (the caller's existing
+ * path) or need both files written at once, which a single `TextEdit` cannot do.
+ */
+function entryOpsOf(patch, schema) {
+  let entryKey;
+  const ops = [];
+  for (const op of patch) {
+    const cls = classifyJsonValuesOp(schema, op.path);
+    if (cls.kind !== "entry") {
+      return undefined;
+    }
+    // Nested `.jsonValues()` is rejected as a module error long before a fix is
+    // offered; treat it as out of scope rather than writing to a guessed file.
+    if (cls.recordPath.length > 0 || cls.subPath.length === 0) {
+      return undefined;
+    }
+    // `move` and `copy` carry a second path, and `rebaseContentOp` slices `from`
+    // by the same prefix as `path` -- so an op reaching outside this entry would
+    // have its source silently reinterpreted as a path inside this entry's file.
+    if (op.op === "move" || op.op === "copy") {
+      const fromCls = classifyJsonValuesOp(schema, op.from);
+      if (fromCls.kind !== "entry" || fromCls.entryKey !== cls.entryKey) {
+        return undefined;
+      }
+    }
+    if (entryKey !== undefined && entryKey !== cls.entryKey) {
+      return undefined;
+    }
+    entryKey = cls.entryKey;
+    ops.push(op);
+  }
+  if (entryKey === undefined || ops.length === 0) {
+    return undefined;
+  }
+  return {
+    entryKey,
+    ops
+  };
+}
+function readFile(filePath) {
+  try {
+    return fs.readFileSync(filePath, "utf8");
+  } catch {
+    return undefined;
+  }
+}
+
 /**
  * Quick fixes, built by running Val's own fix machinery.
  *
@@ -1908,6 +2093,7 @@ async function createValCodeActions({
   content,
   valRoot,
   moduleFilePath,
+  read,
   remoteHost = process.env.VAL_REMOTE_HOST || DEFAULT_VAL_REMOTE_HOST
 }) {
   const actions = [];
@@ -1949,7 +2135,7 @@ async function createValCodeActions({
       if (!isLocalFix(fix)) {
         continue;
       }
-      const edit = await computeFixEdit({
+      const fixEdit = await computeFixEdit({
         document,
         // A gallery check is reported on the entry but fixed against the record
         // that contains it; everything else fixes where it is reported.
@@ -1963,14 +2149,20 @@ async function createValCodeActions({
         },
         content,
         valRoot,
+        moduleFilePath,
+        read,
         remoteHost
       });
-      if (!edit) {
+      if (!fixEdit) {
         continue;
       }
-      actions.push(CodeAction.create(FIX_TITLES[fix] ?? `Val: ${fix}`, {
+      actions.push(CodeAction.create(FIX_TITLES[fix] ?? `Val: ${fix}`,
+      // Not always `document.uri`: a fix inside a `.jsonValues()` entry
+      // edits the entry's own `*.val.json`, which is a different file from
+      // the one the diagnostic is reported on.
+      {
         changes: {
-          [document.uri]: [edit]
+          [fixEdit.uri]: [fixEdit.edit]
         }
       }, CodeActionKind.QuickFix));
     }
@@ -1983,6 +2175,8 @@ async function computeFixEdit({
   validationError,
   content,
   valRoot,
+  moduleFilePath,
+  read,
   remoteHost
 }) {
   let fixed;
@@ -2001,11 +2195,32 @@ async function computeFixEdit({
     return undefined;
   }
   const before = document.getText();
+  // The value may not be in this file at all. A `.jsonValues()` entry's content
+  // lives in its own `*.val.json`, and applying the patch to the `.val.ts` would
+  // walk into the `c.json(...)` thunk and fail -- which is exactly why no quick
+  // fix was offered inside an entry.
+  if (moduleFilePath) {
+    const entryEdit = jsonEntryEditFor({
+      patch: fixed.patch,
+      schema: content.schema,
+      moduleFilePath,
+      valTsText: before,
+      valRoot,
+      read
+    });
+    if (entryEdit) {
+      return entryEdit;
+    }
+  }
   const patched = patchSourceFile(before, fixed.patch);
   if (result.isErr(patched)) {
     return undefined;
   }
-  return minimalTextEdit(before, patched.value.text, document);
+  const edit = minimalTextEdit(before, patched.value.text, document);
+  return edit && {
+    uri: document.uri,
+    edit
+  };
 }
 
 /**
@@ -3457,6 +3672,12 @@ function createValLanguageServer(connection) {
     void connection.client.register(DidChangeWatchedFilesNotification.type, {
       watchers: [{
         globPattern: "**/*.val.{ts,js}"
+      },
+      // A `.jsonValues()` entry's content is here, not in the `.val.ts`, so
+      // this is the only thing that says an entry changed -- including when
+      // the change is a quick fix the editor just applied.
+      {
+        globPattern: "**/*.val.json"
       }, {
         globPattern: "**/val.modules.{ts,js}"
       }, {
@@ -3564,7 +3785,8 @@ function createValLanguageServer(connection) {
         diagnostics: params.context.diagnostics,
         content: result.content,
         valRoot: project.valRoot,
-        moduleFilePath
+        moduleFilePath,
+        read: readOpenDocument
       })));
       return actions;
     } catch (e) {
@@ -3581,7 +3803,10 @@ function createValLanguageServer(connection) {
   documents.onDidChangeContent(({
     document
   }) => {
-    if (PROJECT_WIDE_FILE_RE.test(uriToPath(document.uri))) {
+    if (PROJECT_WIDE_FILE_RE.test(uriToPath(document.uri)) ||
+    // Same reason as in the watched-files handler: an open, unsaved entry file
+    // is read through the editor overlay, but only a fresh Service sees it.
+    isValJsonEntryUri(document.uri)) {
       // A project-wide fact changed, so every module's cached result is stale --
       // not just this file's. `invalidate()` with no argument clears the content
       // cache too, which the per-module fingerprint check would not.
@@ -3623,6 +3848,13 @@ function createValLanguageServer(connection) {
         projectWide = true;
         continue;
       }
+      // An entry file has no module of its own to invalidate: which module reads
+      // it is recorded in a `.val.ts` import specifier, and the parsed JSON is
+      // cached inside the Service, which only a project-wide invalidate discards.
+      if (isValJsonEntryUri(change.uri)) {
+        projectWide = true;
+        continue;
+      }
       // A file appearing or vanishing under the files directory changes what a
       // media path may complete to.
       publicFiles?.invalidate();
@@ -3671,6 +3903,19 @@ function createValLanguageServer(connection) {
       uri: document.uri,
       diagnostics: []
     });
+    // Closing an entry file REMOVES an overlay: whatever the buffer said stops
+    // being what the module reads, and the modules that read it are still open,
+    // still showing diagnostics computed from a buffer that no longer exists.
+    // (Opening one needs no case of its own -- `TextDocuments` fires
+    // onDidChangeContent for a didOpen too, which the handler above catches.)
+    if (isValJsonEntryUri(document.uri)) {
+      project?.invalidate();
+      for (const open of documents.all()) {
+        if (isValModuleUri(open.uri)) {
+          scheduleValidation(open.uri);
+        }
+      }
+    }
   });
   connection.onShutdown(() => {
     for (const timer of pending.values()) {

package/package.json

@@ -11,7 +11,7 @@
     "lsp",
     "language-server"
   ],
-  "version": "0.108.3",
+  "version": "0.108.5",
   "bin": {
     "val-language-server": "./bin.js"
   },
@@ -29,9 +29,9 @@
     "typescript": "^6.0.3",
     "vscode-languageserver": "^10.1.0",
     "vscode-languageserver-textdocument": "^1.0.14",
-    "@valbuild/server": "0.108.3",
     "@valbuild/core": "0.106.0",
-    "@valbuild/shared": "0.108.0"
+    "@valbuild/shared": "0.108.0",
+    "@valbuild/server": "0.108.5"
   },
   "devDependencies": {
     "@types/jest": "^30.0.0",