@valbuild/language-server 0.123.0 → 0.123.3

package/CHANGELOG.md

@@ -1,5 +1,29 @@
 # @valbuild/language-server
 
+## 0.123.3
+
+### Patch Changes
+
+- [#623](https://github.com/valbuild/val/pull/623) [`4c9369b`](https://github.com/valbuild/val/commit/4c9369bad3f17e96868262e78a4f47361d85319e) Thanks [@freekh](https://github.com/freekh)! - Add the editor quick fix for a `.jsonValues()` entry written inline: **Val: move entry into its own .val.json**.
+
+  The language server already reported the problem — "Entry '…' is written inline … Run 'val validate --fix' to move it" — but offered no way to act on it, so the only remedy was to leave the editor and run the CLI. It now offers a quick fix that creates the `*.val.json` with the entry's content and rewrites the `.val.ts` to `c.json(() => import("./…"))`, in one undoable step.
+
+  The fix is computed from the same code `val validate --fix` runs, so the two write the same files, and it is computed against the buffer you are looking at rather than what is on disk — an unsaved module can be fixed without saving first. It refuses, rather than overwriting, when a file or an unsaved buffer already occupies the target path.
+
+  Requires an editor that honours file creation inside a workspace edit; VS Code does. In an editor that does not announce it, no action is offered rather than one that would rewrite the module to import a file that never got created.
+
+- Updated dependencies [[`4c9369b`](https://github.com/valbuild/val/commit/4c9369bad3f17e96868262e78a4f47361d85319e), [`fb1baff`](https://github.com/valbuild/val/commit/fb1baffead5228d8a86a51af65178b88738d5a64), [`accf4f8`](https://github.com/valbuild/val/commit/accf4f852fe3400d762cc14e80316da741a69a9a), [`aef45ce`](https://github.com/valbuild/val/commit/aef45ce3ef269f1b6221de44a56df0f6a0d9dbbd)]:
+  - @valbuild/server@0.123.3
+  - @valbuild/shared@0.123.3
+
+## 0.123.2
+
+### Patch Changes
+
+- Updated dependencies [[`04b6d4c`](https://github.com/valbuild/val/commit/04b6d4cbbecc131bbaf3c20633af9dad8c857310), [`8e58c34`](https://github.com/valbuild/val/commit/8e58c3495d1bf0f221a57082cb0a3045929722a1)]:
+  - @valbuild/shared@0.123.2
+  - @valbuild/server@0.123.2
+
 ## 0.123.0
 
 ### Patch Changes

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

@@ -7,7 +7,10 @@ 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, read, remoteHost, }: {
+export declare function isWorkspaceEditFix(fix: string): fix is ValidationFix;
+/** Whether the client will honour a file CREATE inside a `WorkspaceEdit`. */
+export declare function canCreateFiles(capabilities: unknown): boolean;
+export declare function createValCodeActions({ document, diagnostics, content, valRoot, moduleFilePath, read, remoteHost, allowCreateFiles, }: {
     document: TextDocument;
     diagnostics: Diagnostic[];
     content: ValModuleContent;
@@ -25,6 +28,11 @@ export declare function createValCodeActions({ document, diagnostics, content, v
      */
     read?: (fsPath: string) => string | undefined;
     remoteHost?: string;
+    /**
+     * Whether the client honours a file CREATE in a `WorkspaceEdit`. Without it
+     * the extract-entry fix is not offered at all — see {@link canCreateFiles}.
+     */
+    allowCreateFiles?: boolean;
 }): Promise<CodeAction[]>;
 /**
  * Quick fix for a module that is not registered in `val.modules`.

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

@@ -2385,6 +2385,26 @@ function readFile(filePath) {
   }
 }
 
+/**
+ * What the client announced it will do with a `WorkspaceEdit`.
+ *
+ * A resource operation — a file created, renamed or deleted as part of an edit —
+ * is silently DROPPED by a client that did not announce it. The rest of the edit
+ * still applies, so a fix that needs one and is offered anyway leaves the
+ * project in a state that is worse than the one it set out to fix: a `.val.ts`
+ * rewritten to import a file that was never created, a path rewritten to a file
+ * that never moved. Hence: probe first, and do not offer the action at all.
+ *
+ * Read defensively. These come from `InitializeParams.capabilities`, which is
+ * whatever the client sent — this is the one place that has to cope with the
+ * field being absent or the wrong shape.
+ */
+function supportsResourceOperation(capabilities, operation) {
+  const workspace = capabilities?.workspace;
+  const operations = workspace?.workspaceEdit?.resourceOperations;
+  return Array.isArray(operations) && operations.includes(operation);
+}
+
 /**
  * Quick fixes, built by running Val's own fix machinery.
  *
@@ -2408,6 +2428,18 @@ const LOCAL_FIXES = ["image:add-metadata", "image:check-metadata", "file:add-met
 // stored metadata, dropping entries whose file has gone. Filesystem only.
 "images:check-all-files", "files:check-all-files"];
 
+/**
+ * Fixes that are local, but are NOT a patch against the document they are
+ * reported on, so they never reach `computeFixEdit`.
+ *
+ * `jsonValues:extract-entry` creates a file and rewrites another — see
+ * {@link createExtractEntryAction}. `createFixPatch` has no branch for it at all
+ * (the fix lives in the server's own `extractJsonValuesEntry`), so routing it
+ * through the patch pipeline would silently produce an empty patch and no
+ * action, which is exactly what it did before this existed.
+ */
+const WORKSPACE_EDIT_FIXES = ["jsonValues:extract-entry"];
+
 /** Human-readable titles; falls back to the fix name for anything unknown. */
 const FIX_TITLES = {
   "image:add-metadata": "Val: add image metadata",
@@ -2415,11 +2447,20 @@ const FIX_TITLES = {
   "file:add-metadata": "Val: add file metadata",
   "file:check-metadata": "Val: update file metadata",
   "images:check-all-files": "Val: update gallery image metadata",
-  "files:check-all-files": "Val: update gallery file metadata"
+  "files:check-all-files": "Val: update gallery file metadata",
+  "jsonValues:extract-entry": "Val: move entry into its own .val.json"
 };
 function isLocalFix(fix) {
   return LOCAL_FIXES.includes(fix);
 }
+function isWorkspaceEditFix(fix) {
+  return WORKSPACE_EDIT_FIXES.includes(fix);
+}
+
+/** Whether the client will honour a file CREATE inside a `WorkspaceEdit`. */
+function canCreateFiles(capabilities) {
+  return supportsResourceOperation(capabilities, "create");
+}
 
 /**
  * Build quick fixes for the diagnostics the client sent back.
@@ -2443,7 +2484,8 @@ async function createValCodeActions({
   valRoot,
   moduleFilePath,
   read,
-  remoteHost = process.env.VAL_REMOTE_HOST || core.DEFAULT_VAL_REMOTE_HOST
+  remoteHost = process.env.VAL_REMOTE_HOST || core.DEFAULT_VAL_REMOTE_HOST,
+  allowCreateFiles = false
 }) {
   const actions = [];
   /**
@@ -2492,6 +2534,26 @@ async function createValCodeActions({
         });
         continue;
       }
+      if (isWorkspaceEditFix(fix)) {
+        if (offered.has(`${data.sourcePath}|${fix}`)) {
+          continue;
+        }
+        const action = createExtractEntryAction({
+          document,
+          sourcePath: data.sourcePath,
+          content,
+          valRoot,
+          moduleFilePath,
+          read,
+          allowCreateFiles
+        });
+        if (!action) {
+          continue;
+        }
+        offered.add(`${data.sourcePath}|${fix}`);
+        actions.push(action);
+        continue;
+      }
       if (!isLocalFix(fix)) {
         continue;
       }
@@ -2534,6 +2596,131 @@ async function createValCodeActions({
   }
   return actions;
 }
+
+/**
+ * The quick fix for `jsonValues:extract-entry`: move an entry that was written
+ * inline in the `.val.ts` into its own `*.val.json`.
+ *
+ * Not a patch, and so not `computeFixEdit`. Two files change at once — a
+ * `*.val.json` is created with the entry's content, and the `.val.ts` has the
+ * inline value replaced by `c.json(() => import("./..."))` — and a `Patch` can
+ * only edit one `.val.ts` and cannot create anything. That is why the fix is
+ * `extractJsonValuesEntry` in the server rather than a `createFixPatch` branch,
+ * and why the editor had no fix to offer for it at all until now: the patch
+ * pipeline produced nothing and the action was dropped.
+ *
+ * The plan comes from the same `planJsonValuesEntryExtraction` that
+ * `val validate --fix` runs, so the two cannot write different files; only the
+ * last step differs. Here it is a `WorkspaceEdit`, so the change goes through
+ * the editor's undo stack, and — crucially — is computed against the buffer the
+ * user is looking at rather than what is on disk.
+ */
+function createExtractEntryAction({
+  document,
+  sourcePath,
+  content,
+  valRoot,
+  moduleFilePath,
+  read,
+  allowCreateFiles
+}) {
+  if (!moduleFilePath || !allowCreateFiles) {
+    return undefined;
+  }
+  const [, modulePath] = core.Internal.splitModuleFilePathAndModulePath(sourcePath);
+  const parts = core.Internal.splitModulePath(modulePath);
+  // Root-only by contract, exactly as the server's fix handler asserts: the
+  // entry is a direct child of the module's root record/router.
+  if (parts.length !== 1) {
+    return undefined;
+  }
+  const entryKey = parts[0];
+  const entryContent = entryContentOf(content.source, entryKey);
+  if (entryContent === undefined) {
+    return undefined;
+  }
+  const planned = server.planJsonValuesEntryExtraction({
+    moduleFilePath,
+    entryKey,
+    content: entryContent,
+    valTsPath: uriToPath(document.uri),
+    // The editor's text, not the file's: an edit computed against stale text
+    // has ranges that land in the wrong place.
+    valTsText: document.getText()
+  });
+  if (fp.result.isErr(planned)) {
+    return undefined;
+  }
+  const absoluteJsonPath = path__default["default"].join(valRoot, planned.value.jsonPath);
+  // Same refusal as the CLI's, widened by one case: an unsaved buffer counts as
+  // occupied too. Creating over either would destroy content that a `--fix` run
+  // refuses to touch.
+  if (read?.(absoluteJsonPath) !== undefined || fs__default["default"].existsSync(absoluteJsonPath)) {
+    return undefined;
+  }
+  const valTsEdit = minimalTextEdit(document.getText(), planned.value.valTsContent, document);
+  if (!valTsEdit) {
+    return undefined;
+  }
+  const jsonUri = pathToUri(absoluteJsonPath);
+  return {
+    title: FIX_TITLES["jsonValues:extract-entry"] ,
+    kind: vscodeLanguageserver.CodeActionKind.QuickFix,
+    edit: {
+      // `documentChanges`, not `changes`: a plain edit map cannot create a file,
+      // and an edit addressed to a file that does not exist is an error rather
+      // than a creation.
+      documentChanges: [{
+        kind: "create",
+        uri: jsonUri
+      }, {
+        textDocument: {
+          uri: jsonUri,
+          version: null
+        },
+        edits: [{
+          range: {
+            start: {
+              line: 0,
+              character: 0
+            },
+            end: {
+              line: 0,
+              character: 0
+            }
+          },
+          newText: planned.value.jsonContent
+        }]
+      }, {
+        textDocument: {
+          uri: document.uri,
+          version: null
+        },
+        edits: [valTsEdit]
+      }]
+    }
+  };
+}
+
+/**
+ * One entry's value out of a module's source.
+ *
+ * `Object.entries` rather than an index: the source is a `Source`, which has no
+ * index signature, and reading a dynamic key off it is the one thing this needs
+ * to do. Mirrors what the server's fix handler reads, so the editor extracts the
+ * same bytes `val validate --fix` would.
+ */
+function entryContentOf(source, entryKey) {
+  if (source === null || typeof source !== "object" || Array.isArray(source)) {
+    return undefined;
+  }
+  for (const [key, value] of Object.entries(source)) {
+    if (key === entryKey) {
+      return value;
+    }
+  }
+  return undefined;
+}
 async function computeFixEdit({
   document,
   sourcePath,
@@ -3317,9 +3504,7 @@ function keysOfKeyOf(schema, snapshot) {
  * was — worse than not offering the fix.
  */
 function canRenameFiles(capabilities) {
-  const workspace = capabilities?.workspace;
-  const operations = workspace?.workspaceEdit?.resourceOperations;
-  return Array.isArray(operations) && operations.includes("rename");
+  return supportsResourceOperation(capabilities, "rename");
 }
 async function createGalleryMembershipActions({
   document,
@@ -3792,6 +3977,7 @@ function createValLanguageServer(connection) {
   const documents = new node.TextDocuments(vscodeLanguageserverTextdocument.TextDocument);
   let canRegisterWatchers = false;
   let canRenameFiles$1 = false;
+  let canCreateFiles$1 = false;
 
   /**
    * The editor's view of a file, by absolute path, or `undefined` when the file
@@ -3955,6 +4141,10 @@ function createValLanguageServer(connection) {
     // A RenameFile sent to a client that did not announce resourceOperations is
     // silently dropped, which would rewrite the path and leave the file behind.
     canRenameFiles$1 = canRenameFiles(params.capabilities);
+    // Same reasoning for the extract-entry fix: it CREATES the `*.val.json` the
+    // rewritten `.val.ts` imports, so a client that drops the create would be
+    // left importing a file that is not there.
+    canCreateFiles$1 = canCreateFiles(params.capabilities);
     const clientCapabilities = params.capabilities.experimental?.val ?? {};
 
     // Announce only what this version actually serves: a client hides UI for
@@ -4162,7 +4352,8 @@ function createValLanguageServer(connection) {
         content: result.content,
         valRoot: project.valRoot,
         moduleFilePath,
-        read: readOpenDocument
+        read: readOpenDocument,
+        allowCreateFiles: canCreateFiles$1
       })));
       return actions;
     } catch (e) {

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

@@ -2385,6 +2385,26 @@ function readFile(filePath) {
   }
 }
 
+/**
+ * What the client announced it will do with a `WorkspaceEdit`.
+ *
+ * A resource operation — a file created, renamed or deleted as part of an edit —
+ * is silently DROPPED by a client that did not announce it. The rest of the edit
+ * still applies, so a fix that needs one and is offered anyway leaves the
+ * project in a state that is worse than the one it set out to fix: a `.val.ts`
+ * rewritten to import a file that was never created, a path rewritten to a file
+ * that never moved. Hence: probe first, and do not offer the action at all.
+ *
+ * Read defensively. These come from `InitializeParams.capabilities`, which is
+ * whatever the client sent — this is the one place that has to cope with the
+ * field being absent or the wrong shape.
+ */
+function supportsResourceOperation(capabilities, operation) {
+  const workspace = capabilities?.workspace;
+  const operations = workspace?.workspaceEdit?.resourceOperations;
+  return Array.isArray(operations) && operations.includes(operation);
+}
+
 /**
  * Quick fixes, built by running Val's own fix machinery.
  *
@@ -2408,6 +2428,18 @@ const LOCAL_FIXES = ["image:add-metadata", "image:check-metadata", "file:add-met
 // stored metadata, dropping entries whose file has gone. Filesystem only.
 "images:check-all-files", "files:check-all-files"];
 
+/**
+ * Fixes that are local, but are NOT a patch against the document they are
+ * reported on, so they never reach `computeFixEdit`.
+ *
+ * `jsonValues:extract-entry` creates a file and rewrites another — see
+ * {@link createExtractEntryAction}. `createFixPatch` has no branch for it at all
+ * (the fix lives in the server's own `extractJsonValuesEntry`), so routing it
+ * through the patch pipeline would silently produce an empty patch and no
+ * action, which is exactly what it did before this existed.
+ */
+const WORKSPACE_EDIT_FIXES = ["jsonValues:extract-entry"];
+
 /** Human-readable titles; falls back to the fix name for anything unknown. */
 const FIX_TITLES = {
   "image:add-metadata": "Val: add image metadata",
@@ -2415,11 +2447,20 @@ const FIX_TITLES = {
   "file:add-metadata": "Val: add file metadata",
   "file:check-metadata": "Val: update file metadata",
   "images:check-all-files": "Val: update gallery image metadata",
-  "files:check-all-files": "Val: update gallery file metadata"
+  "files:check-all-files": "Val: update gallery file metadata",
+  "jsonValues:extract-entry": "Val: move entry into its own .val.json"
 };
 function isLocalFix(fix) {
   return LOCAL_FIXES.includes(fix);
 }
+function isWorkspaceEditFix(fix) {
+  return WORKSPACE_EDIT_FIXES.includes(fix);
+}
+
+/** Whether the client will honour a file CREATE inside a `WorkspaceEdit`. */
+function canCreateFiles(capabilities) {
+  return supportsResourceOperation(capabilities, "create");
+}
 
 /**
  * Build quick fixes for the diagnostics the client sent back.
@@ -2443,7 +2484,8 @@ async function createValCodeActions({
   valRoot,
   moduleFilePath,
   read,
-  remoteHost = process.env.VAL_REMOTE_HOST || core.DEFAULT_VAL_REMOTE_HOST
+  remoteHost = process.env.VAL_REMOTE_HOST || core.DEFAULT_VAL_REMOTE_HOST,
+  allowCreateFiles = false
 }) {
   const actions = [];
   /**
@@ -2492,6 +2534,26 @@ async function createValCodeActions({
         });
         continue;
       }
+      if (isWorkspaceEditFix(fix)) {
+        if (offered.has(`${data.sourcePath}|${fix}`)) {
+          continue;
+        }
+        const action = createExtractEntryAction({
+          document,
+          sourcePath: data.sourcePath,
+          content,
+          valRoot,
+          moduleFilePath,
+          read,
+          allowCreateFiles
+        });
+        if (!action) {
+          continue;
+        }
+        offered.add(`${data.sourcePath}|${fix}`);
+        actions.push(action);
+        continue;
+      }
       if (!isLocalFix(fix)) {
         continue;
       }
@@ -2534,6 +2596,131 @@ async function createValCodeActions({
   }
   return actions;
 }
+
+/**
+ * The quick fix for `jsonValues:extract-entry`: move an entry that was written
+ * inline in the `.val.ts` into its own `*.val.json`.
+ *
+ * Not a patch, and so not `computeFixEdit`. Two files change at once — a
+ * `*.val.json` is created with the entry's content, and the `.val.ts` has the
+ * inline value replaced by `c.json(() => import("./..."))` — and a `Patch` can
+ * only edit one `.val.ts` and cannot create anything. That is why the fix is
+ * `extractJsonValuesEntry` in the server rather than a `createFixPatch` branch,
+ * and why the editor had no fix to offer for it at all until now: the patch
+ * pipeline produced nothing and the action was dropped.
+ *
+ * The plan comes from the same `planJsonValuesEntryExtraction` that
+ * `val validate --fix` runs, so the two cannot write different files; only the
+ * last step differs. Here it is a `WorkspaceEdit`, so the change goes through
+ * the editor's undo stack, and — crucially — is computed against the buffer the
+ * user is looking at rather than what is on disk.
+ */
+function createExtractEntryAction({
+  document,
+  sourcePath,
+  content,
+  valRoot,
+  moduleFilePath,
+  read,
+  allowCreateFiles
+}) {
+  if (!moduleFilePath || !allowCreateFiles) {
+    return undefined;
+  }
+  const [, modulePath] = core.Internal.splitModuleFilePathAndModulePath(sourcePath);
+  const parts = core.Internal.splitModulePath(modulePath);
+  // Root-only by contract, exactly as the server's fix handler asserts: the
+  // entry is a direct child of the module's root record/router.
+  if (parts.length !== 1) {
+    return undefined;
+  }
+  const entryKey = parts[0];
+  const entryContent = entryContentOf(content.source, entryKey);
+  if (entryContent === undefined) {
+    return undefined;
+  }
+  const planned = server.planJsonValuesEntryExtraction({
+    moduleFilePath,
+    entryKey,
+    content: entryContent,
+    valTsPath: uriToPath(document.uri),
+    // The editor's text, not the file's: an edit computed against stale text
+    // has ranges that land in the wrong place.
+    valTsText: document.getText()
+  });
+  if (fp.result.isErr(planned)) {
+    return undefined;
+  }
+  const absoluteJsonPath = path__default["default"].join(valRoot, planned.value.jsonPath);
+  // Same refusal as the CLI's, widened by one case: an unsaved buffer counts as
+  // occupied too. Creating over either would destroy content that a `--fix` run
+  // refuses to touch.
+  if (read?.(absoluteJsonPath) !== undefined || fs__default["default"].existsSync(absoluteJsonPath)) {
+    return undefined;
+  }
+  const valTsEdit = minimalTextEdit(document.getText(), planned.value.valTsContent, document);
+  if (!valTsEdit) {
+    return undefined;
+  }
+  const jsonUri = pathToUri(absoluteJsonPath);
+  return {
+    title: FIX_TITLES["jsonValues:extract-entry"] ,
+    kind: vscodeLanguageserver.CodeActionKind.QuickFix,
+    edit: {
+      // `documentChanges`, not `changes`: a plain edit map cannot create a file,
+      // and an edit addressed to a file that does not exist is an error rather
+      // than a creation.
+      documentChanges: [{
+        kind: "create",
+        uri: jsonUri
+      }, {
+        textDocument: {
+          uri: jsonUri,
+          version: null
+        },
+        edits: [{
+          range: {
+            start: {
+              line: 0,
+              character: 0
+            },
+            end: {
+              line: 0,
+              character: 0
+            }
+          },
+          newText: planned.value.jsonContent
+        }]
+      }, {
+        textDocument: {
+          uri: document.uri,
+          version: null
+        },
+        edits: [valTsEdit]
+      }]
+    }
+  };
+}
+
+/**
+ * One entry's value out of a module's source.
+ *
+ * `Object.entries` rather than an index: the source is a `Source`, which has no
+ * index signature, and reading a dynamic key off it is the one thing this needs
+ * to do. Mirrors what the server's fix handler reads, so the editor extracts the
+ * same bytes `val validate --fix` would.
+ */
+function entryContentOf(source, entryKey) {
+  if (source === null || typeof source !== "object" || Array.isArray(source)) {
+    return undefined;
+  }
+  for (const [key, value] of Object.entries(source)) {
+    if (key === entryKey) {
+      return value;
+    }
+  }
+  return undefined;
+}
 async function computeFixEdit({
   document,
   sourcePath,
@@ -3317,9 +3504,7 @@ function keysOfKeyOf(schema, snapshot) {
  * was — worse than not offering the fix.
  */
 function canRenameFiles(capabilities) {
-  const workspace = capabilities?.workspace;
-  const operations = workspace?.workspaceEdit?.resourceOperations;
-  return Array.isArray(operations) && operations.includes("rename");
+  return supportsResourceOperation(capabilities, "rename");
 }
 async function createGalleryMembershipActions({
   document,
@@ -3792,6 +3977,7 @@ function createValLanguageServer(connection) {
   const documents = new node.TextDocuments(vscodeLanguageserverTextdocument.TextDocument);
   let canRegisterWatchers = false;
   let canRenameFiles$1 = false;
+  let canCreateFiles$1 = false;
 
   /**
    * The editor's view of a file, by absolute path, or `undefined` when the file
@@ -3955,6 +4141,10 @@ function createValLanguageServer(connection) {
     // A RenameFile sent to a client that did not announce resourceOperations is
     // silently dropped, which would rewrite the path and leave the file behind.
     canRenameFiles$1 = canRenameFiles(params.capabilities);
+    // Same reasoning for the extract-entry fix: it CREATES the `*.val.json` the
+    // rewritten `.val.ts` imports, so a client that drops the create would be
+    // left importing a file that is not there.
+    canCreateFiles$1 = canCreateFiles(params.capabilities);
     const clientCapabilities = params.capabilities.experimental?.val ?? {};
 
     // Announce only what this version actually serves: a client hides UI for
@@ -4162,7 +4352,8 @@ function createValLanguageServer(connection) {
         content: result.content,
         valRoot: project.valRoot,
         moduleFilePath,
-        read: readOpenDocument
+        read: readOpenDocument,
+        allowCreateFiles: canCreateFiles$1
       })));
       return actions;
     } catch (e) {

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, createFixPatch, parsePersonalAccessTokenFile, getPersonalAccessTokenPath, startValLogin, awaitValLoginConfirmation, persistPersonalAccessToken, ValLoginError, findAndEvalValConfigFile, patchSourceFile, getSettings, uploadRemoteFile, findJsonEntryFilePath, rebaseContentOp, classifyJsonValuesOp, extractImageMetadata, extractFileMetadata } from '@valbuild/server';
+import { fixHandlers, createService, analyzeValModule, createFixPatch, parsePersonalAccessTokenFile, getPersonalAccessTokenPath, startValLogin, awaitValLoginConfirmation, persistPersonalAccessToken, ValLoginError, findAndEvalValConfigFile, patchSourceFile, getSettings, uploadRemoteFile, findJsonEntryFilePath, rebaseContentOp, classifyJsonValuesOp, planJsonValuesEntryExtraction, 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';
@@ -2374,6 +2374,26 @@ function readFile(filePath) {
   }
 }
 
+/**
+ * What the client announced it will do with a `WorkspaceEdit`.
+ *
+ * A resource operation — a file created, renamed or deleted as part of an edit —
+ * is silently DROPPED by a client that did not announce it. The rest of the edit
+ * still applies, so a fix that needs one and is offered anyway leaves the
+ * project in a state that is worse than the one it set out to fix: a `.val.ts`
+ * rewritten to import a file that was never created, a path rewritten to a file
+ * that never moved. Hence: probe first, and do not offer the action at all.
+ *
+ * Read defensively. These come from `InitializeParams.capabilities`, which is
+ * whatever the client sent — this is the one place that has to cope with the
+ * field being absent or the wrong shape.
+ */
+function supportsResourceOperation(capabilities, operation) {
+  const workspace = capabilities?.workspace;
+  const operations = workspace?.workspaceEdit?.resourceOperations;
+  return Array.isArray(operations) && operations.includes(operation);
+}
+
 /**
  * Quick fixes, built by running Val's own fix machinery.
  *
@@ -2397,6 +2417,18 @@ const LOCAL_FIXES = ["image:add-metadata", "image:check-metadata", "file:add-met
 // stored metadata, dropping entries whose file has gone. Filesystem only.
 "images:check-all-files", "files:check-all-files"];
 
+/**
+ * Fixes that are local, but are NOT a patch against the document they are
+ * reported on, so they never reach `computeFixEdit`.
+ *
+ * `jsonValues:extract-entry` creates a file and rewrites another — see
+ * {@link createExtractEntryAction}. `createFixPatch` has no branch for it at all
+ * (the fix lives in the server's own `extractJsonValuesEntry`), so routing it
+ * through the patch pipeline would silently produce an empty patch and no
+ * action, which is exactly what it did before this existed.
+ */
+const WORKSPACE_EDIT_FIXES = ["jsonValues:extract-entry"];
+
 /** Human-readable titles; falls back to the fix name for anything unknown. */
 const FIX_TITLES = {
   "image:add-metadata": "Val: add image metadata",
@@ -2404,11 +2436,20 @@ const FIX_TITLES = {
   "file:add-metadata": "Val: add file metadata",
   "file:check-metadata": "Val: update file metadata",
   "images:check-all-files": "Val: update gallery image metadata",
-  "files:check-all-files": "Val: update gallery file metadata"
+  "files:check-all-files": "Val: update gallery file metadata",
+  "jsonValues:extract-entry": "Val: move entry into its own .val.json"
 };
 function isLocalFix(fix) {
   return LOCAL_FIXES.includes(fix);
 }
+function isWorkspaceEditFix(fix) {
+  return WORKSPACE_EDIT_FIXES.includes(fix);
+}
+
+/** Whether the client will honour a file CREATE inside a `WorkspaceEdit`. */
+function canCreateFiles(capabilities) {
+  return supportsResourceOperation(capabilities, "create");
+}
 
 /**
  * Build quick fixes for the diagnostics the client sent back.
@@ -2432,7 +2473,8 @@ async function createValCodeActions({
   valRoot,
   moduleFilePath,
   read,
-  remoteHost = process.env.VAL_REMOTE_HOST || DEFAULT_VAL_REMOTE_HOST
+  remoteHost = process.env.VAL_REMOTE_HOST || DEFAULT_VAL_REMOTE_HOST,
+  allowCreateFiles = false
 }) {
   const actions = [];
   /**
@@ -2481,6 +2523,26 @@ async function createValCodeActions({
         });
         continue;
       }
+      if (isWorkspaceEditFix(fix)) {
+        if (offered.has(`${data.sourcePath}|${fix}`)) {
+          continue;
+        }
+        const action = createExtractEntryAction({
+          document,
+          sourcePath: data.sourcePath,
+          content,
+          valRoot,
+          moduleFilePath,
+          read,
+          allowCreateFiles
+        });
+        if (!action) {
+          continue;
+        }
+        offered.add(`${data.sourcePath}|${fix}`);
+        actions.push(action);
+        continue;
+      }
       if (!isLocalFix(fix)) {
         continue;
       }
@@ -2523,6 +2585,131 @@ async function createValCodeActions({
   }
   return actions;
 }
+
+/**
+ * The quick fix for `jsonValues:extract-entry`: move an entry that was written
+ * inline in the `.val.ts` into its own `*.val.json`.
+ *
+ * Not a patch, and so not `computeFixEdit`. Two files change at once — a
+ * `*.val.json` is created with the entry's content, and the `.val.ts` has the
+ * inline value replaced by `c.json(() => import("./..."))` — and a `Patch` can
+ * only edit one `.val.ts` and cannot create anything. That is why the fix is
+ * `extractJsonValuesEntry` in the server rather than a `createFixPatch` branch,
+ * and why the editor had no fix to offer for it at all until now: the patch
+ * pipeline produced nothing and the action was dropped.
+ *
+ * The plan comes from the same `planJsonValuesEntryExtraction` that
+ * `val validate --fix` runs, so the two cannot write different files; only the
+ * last step differs. Here it is a `WorkspaceEdit`, so the change goes through
+ * the editor's undo stack, and — crucially — is computed against the buffer the
+ * user is looking at rather than what is on disk.
+ */
+function createExtractEntryAction({
+  document,
+  sourcePath,
+  content,
+  valRoot,
+  moduleFilePath,
+  read,
+  allowCreateFiles
+}) {
+  if (!moduleFilePath || !allowCreateFiles) {
+    return undefined;
+  }
+  const [, modulePath] = Internal.splitModuleFilePathAndModulePath(sourcePath);
+  const parts = Internal.splitModulePath(modulePath);
+  // Root-only by contract, exactly as the server's fix handler asserts: the
+  // entry is a direct child of the module's root record/router.
+  if (parts.length !== 1) {
+    return undefined;
+  }
+  const entryKey = parts[0];
+  const entryContent = entryContentOf(content.source, entryKey);
+  if (entryContent === undefined) {
+    return undefined;
+  }
+  const planned = planJsonValuesEntryExtraction({
+    moduleFilePath,
+    entryKey,
+    content: entryContent,
+    valTsPath: uriToPath(document.uri),
+    // The editor's text, not the file's: an edit computed against stale text
+    // has ranges that land in the wrong place.
+    valTsText: document.getText()
+  });
+  if (result.isErr(planned)) {
+    return undefined;
+  }
+  const absoluteJsonPath = path.join(valRoot, planned.value.jsonPath);
+  // Same refusal as the CLI's, widened by one case: an unsaved buffer counts as
+  // occupied too. Creating over either would destroy content that a `--fix` run
+  // refuses to touch.
+  if (read?.(absoluteJsonPath) !== undefined || fs.existsSync(absoluteJsonPath)) {
+    return undefined;
+  }
+  const valTsEdit = minimalTextEdit(document.getText(), planned.value.valTsContent, document);
+  if (!valTsEdit) {
+    return undefined;
+  }
+  const jsonUri = pathToUri(absoluteJsonPath);
+  return {
+    title: FIX_TITLES["jsonValues:extract-entry"] ,
+    kind: CodeActionKind.QuickFix,
+    edit: {
+      // `documentChanges`, not `changes`: a plain edit map cannot create a file,
+      // and an edit addressed to a file that does not exist is an error rather
+      // than a creation.
+      documentChanges: [{
+        kind: "create",
+        uri: jsonUri
+      }, {
+        textDocument: {
+          uri: jsonUri,
+          version: null
+        },
+        edits: [{
+          range: {
+            start: {
+              line: 0,
+              character: 0
+            },
+            end: {
+              line: 0,
+              character: 0
+            }
+          },
+          newText: planned.value.jsonContent
+        }]
+      }, {
+        textDocument: {
+          uri: document.uri,
+          version: null
+        },
+        edits: [valTsEdit]
+      }]
+    }
+  };
+}
+
+/**
+ * One entry's value out of a module's source.
+ *
+ * `Object.entries` rather than an index: the source is a `Source`, which has no
+ * index signature, and reading a dynamic key off it is the one thing this needs
+ * to do. Mirrors what the server's fix handler reads, so the editor extracts the
+ * same bytes `val validate --fix` would.
+ */
+function entryContentOf(source, entryKey) {
+  if (source === null || typeof source !== "object" || Array.isArray(source)) {
+    return undefined;
+  }
+  for (const [key, value] of Object.entries(source)) {
+    if (key === entryKey) {
+      return value;
+    }
+  }
+  return undefined;
+}
 async function computeFixEdit({
   document,
   sourcePath,
@@ -3306,9 +3493,7 @@ function keysOfKeyOf(schema, snapshot) {
  * was — worse than not offering the fix.
  */
 function canRenameFiles(capabilities) {
-  const workspace = capabilities?.workspace;
-  const operations = workspace?.workspaceEdit?.resourceOperations;
-  return Array.isArray(operations) && operations.includes("rename");
+  return supportsResourceOperation(capabilities, "rename");
 }
 async function createGalleryMembershipActions({
   document,
@@ -3781,6 +3966,7 @@ function createValLanguageServer(connection) {
   const documents = new TextDocuments(TextDocument);
   let canRegisterWatchers = false;
   let canRenameFiles$1 = false;
+  let canCreateFiles$1 = false;
 
   /**
    * The editor's view of a file, by absolute path, or `undefined` when the file
@@ -3944,6 +4130,10 @@ function createValLanguageServer(connection) {
     // A RenameFile sent to a client that did not announce resourceOperations is
     // silently dropped, which would rewrite the path and leave the file behind.
     canRenameFiles$1 = canRenameFiles(params.capabilities);
+    // Same reasoning for the extract-entry fix: it CREATES the `*.val.json` the
+    // rewritten `.val.ts` imports, so a client that drops the create would be
+    // left importing a file that is not there.
+    canCreateFiles$1 = canCreateFiles(params.capabilities);
     const clientCapabilities = params.capabilities.experimental?.val ?? {};
 
     // Announce only what this version actually serves: a client hides UI for
@@ -4151,7 +4341,8 @@ function createValLanguageServer(connection) {
         content: result.content,
         valRoot: project.valRoot,
         moduleFilePath,
-        read: readOpenDocument
+        read: readOpenDocument,
+        allowCreateFiles: canCreateFiles$1
       })));
       return actions;
     } catch (e) {

package/package.json

@@ -11,7 +11,7 @@
     "lsp",
     "language-server"
   ],
-  "version": "0.123.0",
+  "version": "0.123.3",
   "bin": {
     "val-language-server": "./bin.js"
   },
@@ -30,8 +30,8 @@
     "vscode-languageserver": "^10.1.0",
     "vscode-languageserver-textdocument": "^1.0.14",
     "@valbuild/core": "0.121.0",
-    "@valbuild/server": "0.123.0",
-    "@valbuild/shared": "0.123.0"
+    "@valbuild/server": "0.123.3",
+    "@valbuild/shared": "0.123.3"
   },
   "devDependencies": {
     "@types/jest": "^30.0.0",