@valbuild/language-server 0.102.0 → 0.103.1

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

@@ -1,9 +1,9 @@
 import fs from 'fs';
 import path from 'path';
 import ts from 'typescript';
-import { Internal, FILE_REF_PROP, DEFAULT_VAL_REMOTE_HOST } from '@valbuild/core';
-import { createService, analyzeValModule, createFixPatch, patchSourceFile, extractImageMetadata, extractFileMetadata, findAndEvalValConfigFile } from '@valbuild/server';
-import { DiagnosticSeverity, CodeAction, CodeActionKind, CompletionItemKind } from 'vscode-languageserver';
+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 { DiagnosticSeverity, ShowDocumentRequest, ApplyWorkspaceEditRequest, CodeActionKind, CodeAction, CompletionItemKind, DidChangeWatchedFilesNotification } from 'vscode-languageserver';
 import { TextDocuments, TextDocumentSyncKind, createConnection, ProposedFeatures } from 'vscode-languageserver/node';
 import { TextDocument } from 'vscode-languageserver-textdocument';
 import crypto from 'crypto';
@@ -261,6 +261,25 @@ function createEditorFsHost(open) {
 
 /** What `Service.get` returns; re-declared to avoid depending on an internal type. */
 
+/**
+ * A remote that refuses to do anything.
+ *
+ * The handlers that need a remote (upload) are not reachable through
+ * {@link ValProject.runFixHandler}, which reports rather than applies. Passing a
+ * refusing stub keeps the context type honest instead of asserting the field
+ * away, and turns any future miswiring into a message rather than a crash.
+ */
+const reportOnlyRemote = {
+  remoteHost: "",
+  getSettings: () => Promise.resolve({
+    success: false,
+    message: "The language server does not upload while reporting."
+  }),
+  uploadFile: () => Promise.resolve({
+    success: false,
+    error: "The language server does not upload while reporting."
+  })
+};
 const DEFAULT_OPTIONS = {
   validate: true
 };
@@ -469,7 +488,7 @@ function createValProject({
       snapshot
     };
   }
-  return {
+  const project = {
     valRoot,
     async getModule(moduleFilePath, options = DEFAULT_OPTIONS) {
       // Cache on the module's own content as seen by the editor. This covers the
@@ -515,6 +534,50 @@ function createValProject({
       };
     },
     listModuleFilePaths: () => findValModuleFilePaths(valRoot),
+    async runFixHandler({
+      moduleFilePath,
+      sourcePath,
+      validationError,
+      fix = false,
+      remote = reportOnlyRemote,
+      project: projectName,
+      remoteFiles = {}
+    }) {
+      const handlerName = validationError.fixes?.find(fix => fixHandlers[fix] !== undefined);
+      if (!handlerName) {
+        return undefined;
+      }
+      const resolved = await getService();
+      if (resolved.status === "error") {
+        return undefined;
+      }
+      const moduleResult = await project.getModule(moduleFilePath, {
+        validate: false
+      });
+      if (moduleResult.status === "error") {
+        return undefined;
+      }
+      return fixHandlers[handlerName]({
+        sourcePath,
+        validationError,
+        valModule: moduleResult.content,
+        projectRoot: valRoot,
+        // Off by default: applying a fix unasked would write to disk behind the
+        // editor's back, and an accepted quick fix travels as a WorkspaceEdit.
+        // The remote fixes are the exception -- an upload is not expressible as
+        // an edit -- and pass `fix: true` deliberately.
+        fix,
+        service: resolved.service,
+        valFiles: findValModuleFilePaths(valRoot).map(p => p.slice(1)),
+        moduleFilePath,
+        file: moduleFilePath.slice(1),
+        fs: host,
+        remoteFiles,
+        remoteFilesCounter: 0,
+        remote,
+        project: projectName
+      });
+    },
     getSnapshot() {
       // `snapshot` is one shared object handed to every caller, so a second
       // concurrent build must not be allowed to return it half-filled: the
@@ -564,6 +627,7 @@ function createValProject({
       cache.clear();
     }
   };
+  return project;
 }
 
 /**
@@ -718,9 +782,6 @@ function traverse(node, sourceFile) {
   if (ts.isArrayLiteralExpression(node)) {
     return traverseArrayLiteral(node, sourceFile);
   }
-  if (ts.isCallExpression(node)) {
-    return traverseCallExpression(node, sourceFile);
-  }
 }
 
 /**
@@ -728,7 +789,7 @@ function traverse(node, sourceFile) {
  *
  * NOTE: do not compute the start as `end.character - node.getWidth()`. That
  * identity only holds while the node stays on a single line - for a multi-line
- * node (an object inside an array, a `c.image` metadata argument, ...) it
+ * node (an object inside an array, a multi-line media object, ...) it
  * reports the *closing* line and a negative character. `getStart(sourceFile)`
  * needs no parent pointers as long as the source file is passed explicitly,
  * which is why it is safe here.
@@ -739,44 +800,6 @@ function rangeOfNode(node, sourceFile) {
     end: sourceFile.getLineAndCharacterOfPosition(node.getEnd())
   };
 }
-
-/**
- * `c.image(...)` / `c.file(...)` expose three addressable paths: the call itself
- * (`val`), the reference argument (`_ref`) and the metadata argument
- * (`metadata`). Validation errors about a missing file point at `_ref`, and
- * errors about metadata point at `metadata`, so both need their own range.
- */
-function traverseCallExpression(node, sourceFile) {
-  if (!ts.isPropertyAccessExpression(node.expression)) {
-    return undefined;
-  }
-  const isValFileConstructor = node.expression.expression.getText(sourceFile) === "c" && (node.expression.name.getText(sourceFile) === "file" || node.expression.name.getText(sourceFile) === "image");
-  if (!isValFileConstructor || !node.arguments[0]) {
-    return undefined;
-  }
-  const val = {
-    children: {},
-    ...rangeOfNode(node, sourceFile)
-  };
-  const _ref = {
-    children: {},
-    ...rangeOfNode(node.arguments[0], sourceFile)
-  };
-  if (!node.arguments[1]) {
-    return {
-      val,
-      _ref
-    };
-  }
-  return {
-    val,
-    _ref,
-    metadata: {
-      children: {},
-      ...rangeOfNode(node.arguments[1], sourceFile)
-    }
-  };
-}
 function traverseArrayLiteral(node, sourceFile) {
   const map = {};
   node.elements.forEach((element, index) => {
@@ -843,7 +866,13 @@ const VAL_DIAGNOSTIC_CODES = [/** Content does not satisfy the schema. */
 "val/schema", /** The module could not be evaluated at all. */
 "val/fatal", /** A referenced image or file is not on disk. */
 "val/file-not-found", /** The module is not registered in `val.modules`, so Val will not serve it. */
-"val/missing-module"];
+"val/missing-module",
+/**
+ * A gallery-backed media field points at something its gallery does not have.
+ * Reported by core with no `ValidationFix`, because the remedy is an edit to
+ * the gallery module or a file move -- see {@link GalleryMembership}.
+ */
+"val/gallery-membership"];
 
 /**
  * Structured payload attached to every Val diagnostic.
@@ -906,7 +935,8 @@ function createValDiagnostics({
   content,
   text,
   valRoot,
-  snapshot
+  snapshot,
+  galleryChecks
 }) {
   if (content.errors === false) {
     return [];
@@ -937,6 +967,29 @@ function createValDiagnostics({
     for (const error of errors) {
       const fixes = error.fixes;
 
+      // An unconditional gallery placeholder: show it only if the fix handler
+      // found something, and then with the handler's own message rather than
+      // the placeholder's "may have files not tracked by this gallery".
+      if (fixes?.some(isGalleryCheckFix)) {
+        const verdict = galleryChecks?.get(galleryCheckKey(sourcePath, error));
+        for (const finding of verdict ?? []) {
+          diagnostics.push(build(rangeOf(finding.sourcePath, modulePathMap), finding.message, {
+            code: "val/validation",
+            sourcePath: finding.sourcePath,
+            ...(finding.fixes ? {
+              fixes: finding.fixes
+            } : {}),
+            ...(finding.fixSourcePath ? {
+              fixSourcePath: finding.fixSourcePath
+            } : {}),
+            ...(finding.value !== undefined ? {
+              value: finding.value
+            } : {})
+          }));
+        }
+        continue;
+      }
+
       // A file-related fix cannot succeed if the file is not there, and
       // "metadata is incorrect" is a misleading way to say "the file is
       // missing". Report the real problem instead, exactly as the CLI's fix
@@ -947,13 +1000,33 @@ function createValDiagnostics({
         valRoot
       }) : undefined;
       if (missing) {
-        diagnostics.push(build(rangeOf(sourcePath, modulePathMap, "_ref"), `File ${missing} does not exist`, {
+        diagnostics.push(build(rangeOf(sourcePath, modulePathMap, "path"), `File ${missing} does not exist`, {
           code: "val/file-not-found",
           sourcePath,
           filePath: missing
         }));
         continue;
       }
+
+      // A gallery-backed field whose path the gallery does not track. Core
+      // reports it with no fix because the remedy is elsewhere; giving it its
+      // own code is what lets the editor offer the two remedies.
+      const gallery = !fixes?.length && !error.schemaError ? galleryMembershipAt({
+        sourcePath,
+        content,
+        snapshot
+      }) : undefined;
+      if (gallery) {
+        diagnostics.push(build(rangeOf(sourcePath, modulePathMap, "path"), error.message, {
+          code: "val/gallery-membership",
+          sourcePath,
+          gallery,
+          ...(error.value !== undefined ? {
+            value: error.value
+          } : {})
+        }));
+        continue;
+      }
       diagnostics.push(build(rangeOf(sourcePath, modulePathMap), error.message, {
         code: error.schemaError ? "val/schema" : "val/validation",
         sourcePath,
@@ -974,7 +1047,7 @@ function createValDiagnostics({
  * it is not on disk.
  *
  * Mirrors the precondition check in `handleFileMetadata`
- * (`packages/cli/src/runValidation.ts`): resolve the path, read `FILE_REF_PROP`,
+ * (`packages/cli/src/runValidation.ts`): resolve the path, read its `path`,
  * check the file exists.
  */
 function missingFileRef({
@@ -988,7 +1061,7 @@ function missingFileRef({
   try {
     const [, modulePath] = Internal.splitModuleFilePathAndModulePath(sourcePath);
     const resolved = Internal.resolvePath(modulePath, content.source, content.schema);
-    const ref = resolved.source?.[FILE_REF_PROP];
+    const ref = resolved.source?.path;
     if (typeof ref !== "string") {
       return undefined;
     }
@@ -1038,7 +1111,7 @@ function createMissingModuleDiagnostic({
     sourcePath: moduleFilePath
   });
 }
-function rangeOf(sourcePath, modulePathMap, /** Optional child segment to prefer, for example `_ref`. */
+function rangeOf(sourcePath, modulePathMap, /** Optional child segment to prefer, for example `path`. */
 preferChild) {
   if (!modulePathMap) {
     return FALLBACK_RANGE;
@@ -1070,6 +1143,88 @@ preferChild) {
   } : FALLBACK_RANGE;
 }
 
+/**
+ * Gallery checks core emits unconditionally.
+ *
+ * `RecordSchema.validate` attaches these to every `s.images()` / `s.files()`
+ * module whether or not anything is actually wrong (see
+ * `packages/core/src/schema/record.ts`): they are placeholders asking someone to
+ * go and look. `val validate` looks by running the matching fix handler, which
+ * reports success when the directory is unique and every file is accounted for.
+ *
+ * An editor has to do the same. Publishing them as-is put two permanent warnings
+ * on every gallery module in the project — which is worse than useless, because
+ * a warning that is always there is one nobody reads.
+ */
+const GALLERY_CHECK_FIXES = ["images:check-unique-folder", "files:check-unique-folder", "images:check-all-files", "files:check-all-files"];
+function isGalleryCheckFix(fix) {
+  return GALLERY_CHECK_FIXES.includes(fix);
+}
+
+/**
+ * One real problem found behind a gallery placeholder.
+ *
+ * A single placeholder can expand into several of these, each pointing at its
+ * own entry: `handleCheckAllFiles` reporting `shouldApplyPatch` means "no
+ * membership problem, now check the metadata", and `createFixPatch` then returns
+ * one error per entry whose stored metadata disagrees with its file. This is why
+ * the verdict is a list rather than a message, and why each carries its own
+ * source path.
+ */
+
+/**
+ * The verdict on one gallery check. Empty means nothing is wrong and the
+ * placeholder is dropped.
+ */
+
+/**
+ * Adjudicate every gallery placeholder in `validation`, by running the same fix
+ * handler `val validate` runs.
+ *
+ * Async and therefore separate from {@link createValDiagnostics}, which stays
+ * synchronous so it can be tested without a project. The caller runs this first
+ * and passes the result in.
+ */
+async function resolveGalleryChecks({
+  validation,
+  runHandler
+}) {
+  const verdicts = new Map();
+  for (const [sourcePath, errors] of Object.entries(validation)) {
+    for (const error of errors) {
+      if (!error.fixes?.some(isGalleryCheckFix)) {
+        continue;
+      }
+      const key = galleryCheckKey(sourcePath, error);
+      try {
+        verdicts.set(key, await runHandler(sourcePath, error));
+      } catch {
+        // A handler that threw tells us nothing about the gallery. Keep the
+        // placeholder rather than silently claiming the gallery is fine.
+        verdicts.set(key, [{
+          sourcePath,
+          message: error.message,
+          ...(error.fixes ? {
+            fixes: error.fixes
+          } : {}),
+          ...(error.value !== undefined ? {
+            value: error.value
+          } : {})
+        }]);
+      }
+    }
+  }
+  return verdicts;
+}
+
+/**
+ * Key for one placeholder. A gallery module carries several, all at the same
+ * source path, so the fix names have to be part of the key.
+ */
+function galleryCheckKey(sourcePath, error) {
+  return `${sourcePath}|${(error.fixes ?? []).join(",")}`;
+}
+
 /** Fixes core cannot resolve without a project-wide snapshot. */
 const DEFERRED_FIXES = ["keyof:check-keys", "router:check-route"];
 
@@ -1089,119 +1244,69 @@ function dropDeferredPlaceholders(validation) {
 }
 
 /**
- * Quick fixes, built by running Val's own fix machinery.
+ * A gallery-backed field pointing at something the gallery does not have.
  *
- * The pipeline is deliberately the same one `val validate --fix` uses:
- *
- *   ValidationError -> createFixPatch -> Patch -> patchSourceFile -> TextEdit
- *
- * so an editor fix and a CLI fix cannot diverge. The previous VS Code extension
- * hand-wrote AST edits per fix kind, which is how the two drifted apart.
- */
-
-/**
- * Fixes that can be computed locally, without network access or credentials.
+ * `ImageSchema.validate` reports this (`packages/core/src/schema/image.ts`:
+ * "The gallery does not have an image at '…'") but attaches no `ValidationFix`,
+ * because the remedy is not a change to this module: either the gallery gains an
+ * entry, or the file moves into the gallery's directory. Both are edits to
+ * somewhere else, which is not what a `ValidationFix` describes.
  *
- * Remote upload/download need a logged-in session and are handled by a separate
- * flow, so they are not offered as plain quick fixes: a code action that
- * silently required auth would just fail.
+ * So the fix is built in the editor instead, and this is what it needs. Derived
+ * from the **schema**, not from the message: matching on message text would break
+ * the moment the wording changed, silently.
  */
-const LOCAL_FIXES = ["image:add-metadata", "image:check-metadata", "file:add-metadata", "file:check-metadata",
-// Gallery metadata: createFixPatch reads each entry's file and corrects the
-// stored metadata, dropping entries whose file has gone. Filesystem only.
-"images:check-all-files", "files:check-all-files"];
-
-/** Human-readable titles; falls back to the fix name for anything unknown. */
-const FIX_TITLES = {
-  "image:add-metadata": "Val: add image metadata",
-  "image:check-metadata": "Val: update image metadata",
-  "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"
-};
-function isLocalFix(fix) {
-  return LOCAL_FIXES.includes(fix);
-}
 
-/**
- * Build quick fixes for the diagnostics the client sent back.
- *
- * The client returns our `Diagnostic.data` verbatim, which is where the source
- * path and available fixes come from — no re-deriving them from a code string.
- */
-async function createValCodeActions({
-  document,
-  diagnostics,
-  content,
-  valRoot,
-  remoteHost = process.env.VAL_REMOTE_HOST || DEFAULT_VAL_REMOTE_HOST
-}) {
-  const actions = [];
-  for (const diagnostic of diagnostics) {
-    const data = diagnostic.data;
-    if (!data?.fixes?.length) {
-      continue;
-    }
-    for (const fix of data.fixes) {
-      if (!isLocalFix(fix)) {
-        continue;
-      }
-      const edit = await computeFixEdit({
-        document,
-        sourcePath: data.sourcePath,
-        // createFixPatch works one fix at a time; give it exactly this one so a
-        // failing sibling fix cannot suppress this action.
-        validationError: {
-          message: diagnostic.message,
-          value: data.value,
-          fixes: [fix]
-        },
-        content,
-        valRoot,
-        remoteHost
-      });
-      if (!edit) {
-        continue;
-      }
-      actions.push(CodeAction.create(FIX_TITLES[fix] ?? `Val: ${fix}`, {
-        changes: {
-          [document.uri]: [edit]
-        }
-      }, CodeActionKind.QuickFix));
-    }
-  }
-  return actions;
-}
-async function computeFixEdit({
-  document,
+function galleryMembershipAt({
   sourcePath,
-  validationError,
   content,
-  valRoot,
-  remoteHost
+  snapshot
 }) {
-  let fixed;
+  if (!content.source || !content.schema) {
+    return undefined;
+  }
+  let resolved;
   try {
-    fixed = await createFixPatch({
-      projectRoot: valRoot,
-      remoteHost
-    },
-    // `true` means "produce the patch"; nothing is written to disk here, the
-    // patch is applied to the editor's text and returned as an edit.
-    true, sourcePath, validationError, {}, content.source, content.schema);
+    const [, modulePath] = Internal.splitModuleFilePathAndModulePath(sourcePath);
+    resolved = Internal.resolvePath(modulePath, content.source, content.schema);
   } catch {
     return undefined;
   }
-  if (!fixed || fixed.patch.length === 0) {
+  const schema = resolved.schema;
+  if (!schema || typeof schema !== "object" || !("type" in schema) || schema.type !== "image" && schema.type !== "file") {
     return undefined;
   }
-  const before = document.getText();
-  const patched = patchSourceFile(before, fixed.patch);
-  if (result.isErr(patched)) {
+  const referencedModule = "referencedModule" in schema && typeof schema.referencedModule === "string" ? schema.referencedModule : undefined;
+  if (!referencedModule) {
     return undefined;
   }
-  return minimalTextEdit(before, patched.value.text, document);
+  const source = resolved.source;
+  const currentPath = source && typeof source === "object" && "path" in source ? source.path : undefined;
+  if (typeof currentPath !== "string") {
+    return undefined;
+  }
+  const gallery = snapshot?.schemas[referencedModule];
+  const directory = gallery?.type === "record" && typeof gallery.directory === "string" ? gallery.directory : undefined;
+  // Core emits TWO fixless errors on a gallery-backed field: this one, and "an
+  // image from a gallery must not carry its own width, height...". Both look
+  // identical from here, and offering "add it to the gallery" for the second
+  // would be nonsense. The path already being a key in the gallery is what tells
+  // them apart, so without a snapshot to check against, claim nothing.
+  const entries = snapshot?.sources[referencedModule];
+  if (entries === undefined || entries === null || typeof entries !== "object" || Array.isArray(entries)) {
+    return undefined;
+  }
+  if (currentPath in entries) {
+    return undefined;
+  }
+  return {
+    referencedModule,
+    ...(directory !== undefined ? {
+      directory
+    } : {}),
+    path: currentPath,
+    mediaType: schema.type
+  };
 }
 
 /**
@@ -1236,81 +1341,874 @@ function minimalTextEdit(before, after, document) {
 }
 
 /**
- * Works out what the cursor is sitting in, so completions can be offered for it.
+ * `workspace/executeCommand` handlers.
+ *
+ * Quick fixes that only rewrite text travel as a `WorkspaceEdit` and need no
+ * command. These three cannot:
+ *
+ *  - **login** has no edit at all; it opens a browser and waits.
+ *  - **upload-remote** sends bytes to a remote host, which needs credentials and
+ *    is not expressible as an edit. Only the resulting rewrite is.
+ *  - **download-remote** writes a file to disk before the rewrite makes sense.
+ *
+ * Routing them through `executeCommand` is what keeps editors free of Val
+ * knowledge: a code action carries a `command` name the server advertised, and
+ * the LSP client forwards it back without understanding it. `vscode-languageclient`
+ * registers every advertised command automatically, and a Neovim client does the
+ * same through `vim.lsp.buf.code_action`, so neither needs a line of Val-specific
+ * code for any of this.
+ */
+/** Names advertised in `executeCommandProvider.commands`. */
+const VAL_LOGIN_COMMAND = "val.login";
+const VAL_UPLOAD_REMOTE_COMMAND = "val.uploadRemote";
+const VAL_DOWNLOAD_REMOTE_COMMAND = "val.downloadRemote";
+
+/**
+ * The remote fixes, and which command each is offered through.
  *
- * AST-based rather than text/regex-based: `c.image(` can be nested, wrapped or
- * multi-line, and matching on text gets that wrong in exactly the cases where a
- * user most wants help.
+ * Kept apart from `LOCAL_FIXES` in `codeActions.ts` deliberately: a quick fix
+ * that silently needed credentials would just fail, so these are offered as
+ * commands and can report "you are not logged in" like a normal outcome.
  */
+const REMOTE_FIX_COMMANDS = {
+  "image:upload-remote": VAL_UPLOAD_REMOTE_COMMAND,
+  "file:upload-remote": VAL_UPLOAD_REMOTE_COMMAND,
+  "images:upload-remote": VAL_UPLOAD_REMOTE_COMMAND,
+  "files:upload-remote": VAL_UPLOAD_REMOTE_COMMAND,
+  "image:download-remote": VAL_DOWNLOAD_REMOTE_COMMAND,
+  "file:download-remote": VAL_DOWNLOAD_REMOTE_COMMAND
+};
+const REMOTE_FIX_TITLES = {
+  "image:upload-remote": "Val: upload this image to Val Remote",
+  "file:upload-remote": "Val: upload this file to Val Remote",
+  "images:upload-remote": "Val: upload this gallery's images to Val Remote",
+  "files:upload-remote": "Val: upload this gallery's files to Val Remote",
+  "image:download-remote": "Val: download this image into the project",
+  "file:download-remote": "Val: download this file into the project"
+};
 
-/** The cursor is inside a plain string in the module's content. */
+/** Arguments a remote-fix command is invoked with. */
+
+/** Whether a fix is offered as a command rather than as a plain edit. */
+function isRemoteFix(fix) {
+  return Object.prototype.hasOwnProperty.call(REMOTE_FIX_COMMANDS, fix);
+}
+function valCommandNames() {
+  return [VAL_LOGIN_COMMAND, VAL_UPLOAD_REMOTE_COMMAND, VAL_DOWNLOAD_REMOTE_COMMAND];
+}
 
 /**
- * The offsets of a string literal's contents, excluding its quotes.
+ * Read the project's personal access token.
  *
- * A client that does not auto-close quotes leaves `c.image("` unterminated while
- * the user types. TypeScript still produces a string-literal node for it, but the
- * node ends *at* the cursor rather than one character past it, so the usual
- * `getEnd() - 1` bound excludes every position inside the literal and no
- * completions are offered at all. The closing quote is therefore counted rather
- * than assumed.
+ * Same file the CLI writes and the dev server reads (`<root>/.val/pat.json`), so
+ * logging in through either is logging in for both.
  */
-function contentRangeOf(node, sourceFile) {
-  const raw = node.getText(sourceFile);
-  const quote = raw[0];
-  let closing = 0;
-  if (raw.length >= 2 && raw[raw.length - 1] === quote) {
-    // A quote preceded by an odd number of backslashes is escaped, so it is part
-    // of the contents rather than the terminator.
-    let backslashes = 0;
-    for (let i = raw.length - 2; i >= 1 && raw[i] === "\\"; i--) {
-      backslashes++;
-    }
-    closing = backslashes % 2 === 0 ? 1 : 0;
+function readPersonalAccessToken(valRoot) {
+  try {
+    const parsed = parsePersonalAccessTokenFile(fs.readFileSync(getPersonalAccessTokenPath(valRoot), "utf8"));
+    return parsed.success ? parsed.data.pat : null;
+  } catch {
+    return null;
   }
+}
+
+/**
+ * The remote the upload fixes talk to, built from `@valbuild/server`.
+ *
+ * Same wiring as `packages/cli/src/validate.ts`: the ref's host is
+ * `VAL_REMOTE_HOST`, but the bytes and the project settings go to the content
+ * host. Conflating the two uploads to the wrong place.
+ */
+function createRemote(remoteHost) {
+  const contentHost = process.env.VAL_CONTENT_URL ?? DEFAULT_CONTENT_HOST;
   return {
-    contentStart: node.getStart(sourceFile) + 1,
-    contentEnd: node.getEnd() - closing
+    remoteHost,
+    getSettings: (projectName, options) => getSettings(projectName, options),
+    uploadFile: (project, bucket, fileHash, fileExt, fileBuffer, options) => uploadRemoteFile(contentHost, project, bucket, fileHash,
+    // The handler types this optional; an empty extension is what the CLI
+    // ends up sending for a file with none.
+    fileExt ?? "", fileBuffer, options)
   };
 }
 
 /**
- * Find the innermost `c.image(...)` / `c.file(...)` call whose first argument
- * contains `offset`.
+ * A work-done progress the client can show, and cancel.
+ *
+ * `createWorkDoneProgress` needs the client to have announced
+ * `window.workDoneProgress`; when it has not, this degrades to a plain message
+ * and a signal nobody aborts, rather than failing the command. The
+ * `AbortSignal` is what connects a user pressing cancel to
+ * `awaitValLoginConfirmation`, which takes one precisely so an editor can drive
+ * it.
  */
-function getValCompletionContext(sourceFile, offset) {
-  let found;
-  let innermostString;
-  let innermostStringContent;
-  // Tracked explicitly: `ts.createSourceFile` does not set parent pointers
-  // unless asked, so `node.parent` cannot be relied on here.
-  let innermostStringParent;
-  function visit(node, parent) {
-    if (offset < node.getStart(sourceFile) || offset > node.getEnd()) {
+async function withProgress(connection, title, message) {
+  const controller = new AbortController();
+  try {
+    const reporter = await connection.window.createWorkDoneProgress();
+    reporter.begin(title, undefined, message, true);
+    reporter.token.onCancellationRequested(() => controller.abort());
+    let finished = false;
+    return {
+      signal: controller.signal,
+      done: () => {
+        if (!finished) {
+          finished = true;
+          reporter.done();
+        }
+      }
+    };
+  } catch {
+    connection.window.showInformationMessage(`${title}. ${message}`);
+    return {
+      signal: controller.signal,
+      done: () => {}
+    };
+  }
+}
+function createValCommands(deps) {
+  const remoteHost = deps.remoteHost ?? process.env.VAL_REMOTE_HOST ?? DEFAULT_VAL_REMOTE_HOST;
+  async function login() {
+    const project = deps.getProject();
+    if (!project) {
       return;
     }
-    if (ts.isCallExpression(node)) {
-      const subType = fileConstructorSubType(node, sourceFile);
-      const [refArg] = node.arguments;
-      const refContent = refArg && ts.isStringLiteralLike(refArg) ? contentRangeOf(refArg, sourceFile) : undefined;
-      if (subType && refArg && ts.isStringLiteralLike(refArg) && refContent &&
-      // Inside the quotes, inclusive of both ends so completion works on an
-      // empty string and at either edge.
-      offset >= refContent.contentStart && offset <= refContent.contentEnd) {
-        const metadataArg = node.arguments[1];
-        found = {
-          kind: "file-ref",
-          subType,
-          currentText: refArg.text,
-          ...refContent,
-          refArgStart: refArg.getStart(sourceFile),
-          refArgEnd: refArg.getEnd(),
-          ...(metadataArg ? {
-            metadataStart: metadataArg.getStart(sourceFile),
-            metadataEnd: metadataArg.getEnd()
+    const {
+      connection
+    } = deps;
+    try {
+      const session = await startValLogin();
+      // `showDocument` with `external` is the standard way to reach a browser;
+      // there is no Val-specific request for it, which is what lets any LSP
+      // client drive this flow.
+      await connection.sendRequest(ShowDocumentRequest.type, {
+        uri: session.url,
+        external: true
+      });
+      // The poll runs for up to five minutes. Without progress the editor looks
+      // hung, and there is nothing to tell the user the browser is the next step.
+      const progress = await withProgress(connection, "Val: waiting for login", "Complete the login in your browser.");
+      let confirmed;
+      try {
+        confirmed = await awaitValLoginConfirmation(session.nonce, {
+          signal: progress.signal
+        });
+      } finally {
+        progress.done();
+      }
+      const filePath = persistPersonalAccessToken(project.valRoot, confirmed);
+      connection.window.showInformationMessage(`Val: logged in as ${confirmed.profile.email} (token saved to ${filePath}).`);
+    } catch (e) {
+      const message = e instanceof ValLoginError ? e.message : e instanceof Error ? e.message : String(e);
+      deps.connection.window.showErrorMessage(`Val: login failed. ${message}`);
+    }
+  }
+  async function remoteFix(args) {
+    const project = deps.getProject();
+    const document = deps.getDocument(args.uri);
+    const {
+      connection
+    } = deps;
+    if (!project || !document) {
+      return;
+    }
+    const isUpload = args.fix.endsWith(":upload-remote");
+    let projectName;
+    if (isUpload) {
+      // Uploading needs both a project name and a token; saying which one is
+      // missing is the difference between an actionable message and a shrug.
+      const pat = readPersonalAccessToken(project.valRoot);
+      if (!pat) {
+        connection.window.showErrorMessage(`Val: you are not logged in. Run "${VAL_LOGIN_COMMAND}" first.`);
+        return;
+      }
+      const config = await findAndEvalValConfigFile(project.valRoot).catch(() => null);
+      projectName = config?.project;
+      if (!projectName) {
+        connection.window.showErrorMessage("Val: no `project` in val.config, so there is nowhere to upload to.");
+        return;
+      }
+    }
+    const remoteFiles = {};
+    const validationError = {
+      message: args.message,
+      value: args.value,
+      fixes: [args.fix]
+    };
+
+    // Bytes over the network: how long depends on the file, so the editor needs
+    // to say something is happening.
+    const progress = await withProgress(connection, isUpload ? "Val: uploading to Val Remote" : "Val: downloading from Val Remote", args.sourcePath);
+    let outcome;
+    try {
+      outcome = await project.runFixHandler({
+        moduleFilePath: args.moduleFilePath,
+        sourcePath: args.sourcePath,
+        validationError,
+        // The upload or download itself is the point; it cannot be an edit.
+        fix: true,
+        remote: createRemote(remoteHost),
+        ...(projectName ? {
+          project: projectName
+        } : {}),
+        remoteFiles
+      });
+    } catch (e) {
+      progress.done();
+      connection.window.showErrorMessage(`Val: ${args.fix} failed. ${e instanceof Error ? e.message : String(e)}`);
+      return;
+    }
+    progress.done();
+    if (!outcome) {
+      connection.window.showErrorMessage(`Val: could not run ${args.fix} — the project would not evaluate.`);
+      return;
+    }
+    if (!outcome.success) {
+      connection.window.showErrorMessage(`Val: ${outcome.errorMessage ?? `${args.fix} failed.`}`);
+      return;
+    }
+    if (!outcome.shouldApplyPatch) {
+      // The handler did the work and there is nothing left to rewrite.
+      return;
+    }
+    const moduleResult = await project.getModule(args.moduleFilePath, {
+      validate: false
+    });
+    if (moduleResult.status === "error") {
+      return;
+    }
+    let fixed;
+    try {
+      fixed = await createFixPatch({
+        projectRoot: project.valRoot,
+        remoteHost
+      }, true, args.sourcePath, validationError, remoteFiles, moduleResult.content.source, moduleResult.content.schema);
+    } catch (e) {
+      connection.window.showErrorMessage(`Val: ${args.fix} could not be written. ${e instanceof Error ? e.message : String(e)}`);
+      return;
+    }
+    if (!fixed || fixed.patch.length === 0) {
+      return;
+    }
+    const before = document.getText();
+    const patched = patchSourceFile(before, fixed.patch);
+    if (result.isErr(patched)) {
+      connection.window.showErrorMessage(`Val: ${args.fix} produced a patch that would not apply.`);
+      return;
+    }
+    const edit = minimalTextEdit(before, patched.value.text, document);
+    if (!edit) {
+      return;
+    }
+    // Applied through the client so it lands in the editor's undo history,
+    // rather than written to disk under the user's cursor.
+    await connection.sendRequest(ApplyWorkspaceEditRequest.type, {
+      label: REMOTE_FIX_TITLES[args.fix] ?? `Val: ${args.fix}`,
+      edit: {
+        changes: {
+          [args.uri]: [edit]
+        }
+      }
+    });
+  }
+  return {
+    async execute(command, args) {
+      if (command === VAL_LOGIN_COMMAND) {
+        await login();
+        return;
+      }
+      if (command === VAL_UPLOAD_REMOTE_COMMAND || command === VAL_DOWNLOAD_REMOTE_COMMAND) {
+        const [raw] = args;
+        if (!isRemoteFixCommandArgs(raw)) {
+          deps.connection.console.error(`Val: ${command} called with unexpected arguments.`);
+          return;
+        }
+        await remoteFix(raw);
+        return;
+      }
+      deps.connection.console.error(`Val: unknown command ${command}.`);
+    }
+  };
+}
+function isRemoteFixCommandArgs(raw) {
+  if (raw === null || typeof raw !== "object") {
+    return false;
+  }
+  const candidate = raw;
+  return typeof candidate.uri === "string" && typeof candidate.moduleFilePath === "string" && typeof candidate.sourcePath === "string" && typeof candidate.fix === "string" && typeof candidate.message === "string";
+}
+
+/**
+ * Works out which Val modules a `val.modules.{ts,js}` file registers.
+ *
+ * Val only serves modules listed there, so an unregistered `.val.ts` file
+ * silently does nothing.
+ *
+ * Rather than pattern-matching the accepted authoring shapes — `config.modules([…])`
+ * vs `modules(config, […])`, bare `import("./x.val")` vs
+ * `{ def: () => import("./x.val") }` — this collects *every* dynamic import
+ * specifier in the file. That is deliberate:
+ *
+ *  - it covers all current shapes with one rule, and any shape added later;
+ *  - when in doubt it over-reports registration, so a new authoring form makes
+ *    the diagnostic go quiet rather than firing a false "missing module" on
+ *    every file, which is the failure mode that actually hurts.
+ */
+function findRegisteredModuleSpecifiers(sourceFile) {
+  const specifiers = [];
+  function visit(node) {
+    if (ts.isCallExpression(node) && node.expression.kind === ts.SyntaxKind.ImportKeyword) {
+      const [arg] = node.arguments;
+      if (arg && ts.isStringLiteralLike(arg)) {
+        specifiers.push(arg.text);
+      }
+    }
+    ts.forEachChild(node, visit);
+  }
+  visit(sourceFile);
+  return specifiers;
+}
+
+/**
+ * Whether `moduleFilePath` is registered by the given `val.modules` file.
+ *
+ * @param valModulesDir directory containing the val.modules file, relative to
+ *   the Val root (`""` when it sits at the root).
+ * @param moduleFilePath the module's path, Val-style: root-relative, leading
+ *   slash, with extension (for example `/content/page.val.ts`).
+ */
+function isModuleRegistered({
+  sourceFile,
+  valModulesDir,
+  moduleFilePath
+}) {
+  const target = stripValModuleExtension(moduleFilePath);
+  return findRegisteredModuleSpecifiers(sourceFile).some(specifier => {
+    // Specifiers are written relative to the val.modules file and normally omit
+    // the extension ("./content/page.val").
+    const resolved = specifier.startsWith(".") ? path.posix.normalize(path.posix.join("/", valModulesDir, stripValModuleExtension(specifier))) : stripValModuleExtension(specifier);
+    return resolved === target;
+  });
+}
+
+/** `/content/page.val.ts` -> `/content/page.val` (also handles `.val` already). */
+function stripValModuleExtension(specifier) {
+  return specifier.replace(/\.val\.(ts|js|tsx|jsx)$/, ".val");
+}
+
+/**
+ * Where to insert a new entry in a `val.modules` file, and how to indent it.
+ *
+ * Only `modules(config, [ … ])` is matched, because that is the shape Val
+ * actually accepts and the shape `examples/next/val.modules.ts` uses. The
+ * over-reporting rule in {@link findRegisteredModuleSpecifiers} is right for
+ * *reading* a file someone else wrote; writing into one has to commit to a
+ * shape, and guessing wrong produces a file that no longer compiles.
+ *
+ * Returns `null` when the array cannot be found — the caller then offers no fix
+ * rather than inserting somewhere arbitrary.
+ */
+function findValModulesInsertion(sourceFile) {
+  let found = null;
+  function visit(node) {
+    if (found === null && ts.isCallExpression(node) && ts.isIdentifier(node.expression) && node.expression.text === "modules" && node.arguments.length >= 2) {
+      const array = node.arguments[1];
+      if (ts.isArrayLiteralExpression(array)) {
+        if (array.elements.length > 0) {
+          const last = array.elements[array.elements.length - 1];
+          const first = array.elements[0];
+          const {
+            character
+          } = sourceFile.getLineAndCharacterOfPosition(first.getStart(sourceFile));
+          found = {
+            insertOffset: last.end,
+            indentation: " ".repeat(character),
+            hasElements: true
+          };
+        } else {
+          found = {
+            // Just after the `[`.
+            insertOffset: array.getStart(sourceFile) + 1,
+            indentation: "  ",
+            hasElements: false
+          };
+        }
+        return;
+      }
+    }
+    ts.forEachChild(node, visit);
+  }
+  visit(sourceFile);
+  return found;
+}
+
+/**
+ * The specifier to write for `moduleFilePath`, relative to the `val.modules`
+ * file that will hold it.
+ *
+ * Both paths are Val-style (root-relative, leading slash). POSIX separators
+ * always: the string ends up in an `import()` in source, where a backslash is an
+ * escape rather than a separator.
+ */
+function valModuleSpecifier({
+  valModulesFilePath,
+  moduleFilePath
+}) {
+  const relative = path.posix.relative(path.posix.dirname(valModulesFilePath), stripValModuleExtension(moduleFilePath));
+  return relative.startsWith(".") ? relative : `./${relative}`;
+}
+
+/** The text to insert for one new entry, including its separator. */
+function valModulesEntryText({
+  specifier,
+  indentation,
+  hasElements
+}) {
+  const entry = `{ def: () => import("${specifier}") }`;
+  return hasElements ? `,\n${indentation}${entry}` : `\n${indentation}${entry}\n${indentation.slice(2)}`;
+}
+
+/**
+ * Conversions between LSP document URIs and the paths Val uses.
+ *
+ * Deliberately minimal rather than pulling in `vscode-uri`: the server only ever
+ * deals with local `file:` URIs, and keeping this small makes the assumptions
+ * visible.
+ */
+
+/** Matches the Val module files the server validates. */
+const VAL_MODULE_RE = /\.val\.(ts|js|tsx|jsx)$/;
+
+/** `file:` with an optional authority, capturing authority and path apart. */
+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]:)(\/|$)/;
+function isValModuleUri(uri) {
+  return VAL_MODULE_RE.test(uri);
+}
+
+/**
+ * `decodeURIComponent` throws on malformed escapes (`%zz`). A client that sends
+ * one is broken, but that should not take the server down: fall back to the
+ * undecoded text so the path is at worst not found.
+ */
+function decodeSafely(value) {
+  try {
+    return decodeURIComponent(value);
+  } catch {
+    return value;
+  }
+}
+
+/**
+ * `file:///a/b.val.ts` -> `/a/b.val.ts`
+ *
+ * Percent escapes are decoded, Windows drive letters lose the leading slash
+ * (`file:///c%3A/a` -> `c:/a`), and a URI with an authority is read as a UNC
+ * path (`file://host/share/a` -> `//host/share/a`). Anything that is not a
+ * `file:` URI is passed through unchanged, since callers also hand us plain
+ * paths.
+ */
+function uriToPath(uri) {
+  const match = FILE_URI_RE.exec(uri);
+  if (!match) {
+    return uri;
+  }
+  const authority = decodeSafely(match[1]);
+  const fsPath = decodeSafely(match[2] || "/");
+  if (authority) {
+    return `//${authority}${fsPath}`;
+  }
+  return fsPath.replace(URI_DRIVE_LETTER_RE, "$1$2");
+}
+
+/**
+ * `/a/b.val.ts` -> `file:///a/b.val.ts`
+ *
+ * The escaping matches what VS Code produces (drive-letter colons included), so
+ * that a URI built here can be looked up in the open-document map keyed by the
+ * URIs the client sent.
+ */
+function pathToUri(fsPath) {
+  const normalized = fsPath.split(path.sep).join("/");
+  const rooted = normalized.startsWith("/") ? normalized : `/${normalized}`;
+  return `file://${rooted.split("/").map(segment => encodeURIComponent(segment)).join("/")}`;
+}
+
+/**
+ * Convert a document URI into the `ModuleFilePath` Val addresses it by: a
+ * POSIX-style path relative to the Val root, with a leading slash.
+ *
+ * Returns `undefined` when the file lies outside the Val root — one server
+ * serves exactly one root, so another root's files are not its business.
+ */
+function toModuleFilePath(valRoot, uri) {
+  const fsPath = uriToPath(uri);
+  const relative = path.relative(valRoot, fsPath);
+  if (!relative || relative.startsWith("..") || path.isAbsolute(relative)) {
+    return undefined;
+  }
+  return `/${relative.split(path.sep).join("/")}`;
+}
+
+/**
+ * Quick fixes, built by running Val's own fix machinery.
+ *
+ * The pipeline is deliberately the same one `val validate --fix` uses:
+ *
+ *   ValidationError -> createFixPatch -> Patch -> patchSourceFile -> TextEdit
+ *
+ * so an editor fix and a CLI fix cannot diverge. The previous VS Code extension
+ * hand-wrote AST edits per fix kind, which is how the two drifted apart.
+ */
+
+/**
+ * Fixes that can be computed locally, without network access or credentials.
+ *
+ * Remote upload/download need a logged-in session and are handled by a separate
+ * flow, so they are not offered as plain quick fixes: a code action that
+ * silently required auth would just fail.
+ */
+const LOCAL_FIXES = ["image:add-metadata", "image:check-metadata", "file:add-metadata", "file:check-metadata",
+// Gallery metadata: createFixPatch reads each entry's file and corrects the
+// stored metadata, dropping entries whose file has gone. Filesystem only.
+"images:check-all-files", "files:check-all-files"];
+
+/** Human-readable titles; falls back to the fix name for anything unknown. */
+const FIX_TITLES = {
+  "image:add-metadata": "Val: add image metadata",
+  "image:check-metadata": "Val: update image metadata",
+  "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"
+};
+function isLocalFix(fix) {
+  return LOCAL_FIXES.includes(fix);
+}
+
+/**
+ * Build quick fixes for the diagnostics the client sent back.
+ *
+ * The client returns our `Diagnostic.data` verbatim, which is where the source
+ * path and available fixes come from — no re-deriving them from a code string.
+ */
+async function createValCodeActions({
+  document,
+  diagnostics,
+  content,
+  valRoot,
+  moduleFilePath,
+  remoteHost = process.env.VAL_REMOTE_HOST || DEFAULT_VAL_REMOTE_HOST
+}) {
+  const actions = [];
+  for (const diagnostic of diagnostics) {
+    const data = diagnostic.data;
+    if (!data?.fixes?.length) {
+      continue;
+    }
+    for (const fix of data.fixes) {
+      // Remote fixes upload or download bytes, so they are commands rather than
+      // edits: a quick fix that silently needed credentials would just fail,
+      // whereas a command can say "you are not logged in".
+      if (isRemoteFix(fix)) {
+        const command = REMOTE_FIX_COMMANDS[fix];
+        if (!command || !moduleFilePath) {
+          continue;
+        }
+        const args = {
+          uri: document.uri,
+          moduleFilePath,
+          sourcePath: data.sourcePath,
+          fix,
+          message: diagnostic.message,
+          ...(data.value !== undefined ? {
+            value: data.value
           } : {})
         };
+        actions.push({
+          title: REMOTE_FIX_TITLES[fix] ?? `Val: ${fix}`,
+          kind: CodeActionKind.QuickFix,
+          command: {
+            title: REMOTE_FIX_TITLES[fix] ?? fix,
+            command,
+            arguments: [args]
+          }
+        });
+        continue;
+      }
+      if (!isLocalFix(fix)) {
+        continue;
       }
+      const edit = 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.
+        sourcePath: data.fixSourcePath ?? data.sourcePath,
+        // createFixPatch works one fix at a time; give it exactly this one so a
+        // failing sibling fix cannot suppress this action.
+        validationError: {
+          message: diagnostic.message,
+          value: data.value,
+          fixes: [fix]
+        },
+        content,
+        valRoot,
+        remoteHost
+      });
+      if (!edit) {
+        continue;
+      }
+      actions.push(CodeAction.create(FIX_TITLES[fix] ?? `Val: ${fix}`, {
+        changes: {
+          [document.uri]: [edit]
+        }
+      }, CodeActionKind.QuickFix));
+    }
+  }
+  return actions;
+}
+async function computeFixEdit({
+  document,
+  sourcePath,
+  validationError,
+  content,
+  valRoot,
+  remoteHost
+}) {
+  let fixed;
+  try {
+    fixed = await createFixPatch({
+      projectRoot: valRoot,
+      remoteHost
+    },
+    // `true` means "produce the patch"; nothing is written to disk here, the
+    // patch is applied to the editor's text and returned as an edit.
+    true, sourcePath, validationError, {}, content.source, content.schema);
+  } catch {
+    return undefined;
+  }
+  if (!fixed || fixed.patch.length === 0) {
+    return undefined;
+  }
+  const before = document.getText();
+  const patched = patchSourceFile(before, fixed.patch);
+  if (result.isErr(patched)) {
+    return undefined;
+  }
+  return minimalTextEdit(before, patched.value.text, document);
+}
+
+/**
+ * Quick fix for a module that is not registered in `val.modules`.
+ *
+ * Separate from {@link createValCodeActions} because it is not a
+ * `ValidationError` at all — nothing is wrong with the module's content, it is
+ * simply not listed, so there is no `createFixPatch` path to reuse. The edit
+ * also lands in a *different* file than the diagnostic, which a `WorkspaceEdit`
+ * handles natively and needs no extra client capability.
+ *
+ * Returns nothing when the `val.modules` file cannot be found or its `modules(
+ * config, [ … ])` array cannot be located: an insertion at a guessed offset
+ * produces a file that no longer compiles, which is worse than no fix.
+ */
+function createMissingModuleCodeAction({
+  valRoot,
+  moduleFilePath,
+  read
+}) {
+  for (const candidate of ["val.modules.ts", "val.modules.js"]) {
+    const file = path.join(valRoot, candidate);
+    let text = read(file);
+    if (text === undefined) {
+      try {
+        text = fs.readFileSync(file, "utf8");
+      } catch {
+        continue;
+      }
+    }
+    const sourceFile = ts.createSourceFile(file, text, ts.ScriptTarget.ES2020, true);
+    const insertion = findValModulesInsertion(sourceFile);
+    if (!insertion) {
+      return undefined;
+    }
+    const specifier = valModuleSpecifier({
+      // The val.modules file sits at the Val root, so its Val-style path is its
+      // bare filename with a leading slash.
+      valModulesFilePath: `/${candidate}`,
+      moduleFilePath: moduleFilePath
+    });
+    const position = sourceFile.getLineAndCharacterOfPosition(insertion.insertOffset);
+    const edit = {
+      range: {
+        start: position,
+        end: position
+      },
+      newText: valModulesEntryText({
+        specifier,
+        indentation: insertion.indentation,
+        hasElements: insertion.hasElements
+      })
+    };
+    return CodeAction.create(`Val: register ${path.posix.basename(moduleFilePath)} in ${candidate}`, {
+      changes: {
+        [pathToUri(file)]: [edit]
+      }
+    }, CodeActionKind.QuickFix);
+  }
+  return undefined;
+}
+
+/**
+ * Work out whether a gallery placeholder is hiding a real problem.
+ *
+ * Core attaches `images:check-unique-folder` and `images:check-all-files` to
+ * every gallery module unconditionally — they are requests to go and look, not
+ * findings. `val validate` looks by running the fix handler and then, when the
+ * handler says the membership is fine, by running `createFixPatch` to compare
+ * each entry's stored metadata against its file. Both steps matter:
+ *
+ *  - handler `success: false` — a membership problem, with its own message.
+ *  - handler `shouldApplyPatch` — membership is fine; the metadata still has to
+ *    be checked, and `createFixPatch` returns one `remainingError` per entry
+ *    that disagrees with its file.
+ *  - anything else — nothing to report, so the placeholder is dropped.
+ *
+ * Doing it exactly this way is the point: an editor that adjudicated these
+ * itself would disagree with the CLI, and the first symptom would be a warning
+ * that appears in one and not the other.
+ */
+async function adjudicateGalleryCheck({
+  sourcePath,
+  validationError,
+  moduleFilePath,
+  valRoot,
+  content,
+  runFixHandler,
+  remoteHost = process.env.VAL_REMOTE_HOST || DEFAULT_VAL_REMOTE_HOST
+}) {
+  const outcome = await runFixHandler({
+    moduleFilePath,
+    sourcePath,
+    validationError
+  });
+  if (!outcome) {
+    // No handler, or a project that would not evaluate. Keep the placeholder:
+    // claiming the gallery is fine on no evidence is the worse error.
+    return [{
+      sourcePath,
+      message: validationError.message,
+      ...(validationError.fixes ? {
+        fixes: validationError.fixes
+      } : {}),
+      ...(validationError.value !== undefined ? {
+        value: validationError.value
+      } : {})
+    }];
+  }
+  if (!outcome.success) {
+    return [{
+      sourcePath,
+      message: outcome.errorMessage ?? validationError.message,
+      ...(validationError.fixes ? {
+        fixes: validationError.fixes
+      } : {})
+    }];
+  }
+  if (outcome.fixableErrorMessage) {
+    return [{
+      sourcePath,
+      message: outcome.fixableErrorMessage,
+      ...(validationError.fixes ? {
+        fixes: validationError.fixes
+      } : {})
+    }];
+  }
+  if (!outcome.shouldApplyPatch) {
+    return [];
+  }
+  let fixed;
+  try {
+    fixed = await createFixPatch({
+      projectRoot: valRoot,
+      remoteHost
+    },
+    // `false`: this is a question, not a fix. Asking for the patch would have
+    // createFixPatch read and rewrite files behind the editor's back.
+    false, sourcePath, validationError, {}, content.source, content.schema);
+  } catch {
+    return [];
+  }
+  return (fixed?.remainingErrors ?? []).map(error => ({
+    // A gallery check expands into per-entry errors carrying their own path;
+    // fall back to the record's path when one does not.
+    sourcePath: error.sourcePath ?? sourcePath,
+    message: error.message,
+    ...(error.fixes ? {
+      fixes: error.fixes
+    } : {}),
+    // The fix runs against the record, not the entry: `createFixPatch`'s gallery
+    // branch walks every entry itself and builds patch paths from the record's
+    // path, so handing it the entry's path would write to the wrong place.
+    fixSourcePath: sourcePath,
+    ...(validationError.value !== undefined ? {
+      value: validationError.value
+    } : {})
+  }));
+}
+
+/**
+ * Works out what the cursor is sitting in, so completions can be offered for it.
+ *
+ * AST-based rather than text/regex-based: an object literal can be nested,
+ * wrapped or multi-line, and matching on text gets that wrong in exactly the
+ * cases where a user most wants help.
+ */
+
+/** The cursor is inside a plain string in the module's content. */
+
+/**
+ * The offsets of a string literal's contents, excluding its quotes.
+ *
+ * A client that does not auto-close quotes leaves `path: "` unterminated while
+ * the user types. TypeScript still produces a string-literal node for it, but the
+ * node ends *at* the cursor rather than one character past it, so the usual
+ * `getEnd() - 1` bound excludes every position inside the literal and no
+ * completions are offered at all. The closing quote is therefore counted rather
+ * than assumed.
+ */
+function contentRangeOf(node, sourceFile) {
+  const raw = node.getText(sourceFile);
+  const quote = raw[0];
+  let closing = 0;
+  if (raw.length >= 2 && raw[raw.length - 1] === quote) {
+    // A quote preceded by an odd number of backslashes is escaped, so it is part
+    // of the contents rather than the terminator.
+    let backslashes = 0;
+    for (let i = raw.length - 2; i >= 1 && raw[i] === "\\"; i--) {
+      backslashes++;
+    }
+    closing = backslashes % 2 === 0 ? 1 : 0;
+  }
+  return {
+    contentStart: node.getStart(sourceFile) + 1,
+    contentEnd: node.getEnd() - closing
+  };
+}
+
+/**
+ * The innermost string literal containing `offset`, described well enough for a
+ * schema-driven completion to decide whether it applies.
+ */
+function getValCompletionContext(sourceFile, offset) {
+  let innermostString;
+  let innermostStringContent;
+  // Tracked explicitly: `ts.createSourceFile` does not set parent pointers
+  // unless asked, so `node.parent` cannot be relied on here.
+  let innermostStringParent;
+  function visit(node, parent) {
+    if (offset < node.getStart(sourceFile) || offset > node.getEnd()) {
+      return;
     }
     if (ts.isStringLiteralLike(node)) {
       const content = contentRangeOf(node, sourceFile);
@@ -1323,56 +2221,62 @@ function getValCompletionContext(sourceFile, offset) {
     ts.forEachChild(node, child => visit(child, node));
   }
   visit(sourceFile, undefined);
-  if (found) {
-    return found;
-  }
-  // Not a file reference, but still inside a string: schema-driven completions
-  // (keyOf keys, route paths) decide whether they apply.
-  if (innermostString && innermostStringContent) {
-    return {
-      kind: "string-value",
-      currentText: innermostString.text,
-      ...innermostStringContent,
-      // Uses the parent tracked during the walk, not `node.parent`, which
-      // `ts.createSourceFile` leaves unset unless asked to populate it.
-      isPropertyName: Boolean(innermostStringParent && ts.isPropertyAssignment(innermostStringParent) && innermostStringParent.name === innermostString),
-      ...(innermostStringParent && ts.isPropertyAssignment(innermostStringParent) && innermostStringParent.name !== innermostString && (ts.isIdentifier(innermostStringParent.name) || ts.isStringLiteral(innermostStringParent.name)) ? {
-        valueOfProperty: innermostStringParent.name.text
-      } : {})
-    };
+  if (!innermostString || !innermostStringContent) {
+    return undefined;
   }
-  return undefined;
+  return {
+    kind: "string-value",
+    currentText: innermostString.text,
+    ...innermostStringContent,
+    // Uses the parent tracked during the walk, not `node.parent`, which
+    // `ts.createSourceFile` leaves unset unless asked to populate it.
+    isPropertyName: Boolean(innermostStringParent && ts.isPropertyAssignment(innermostStringParent) && innermostStringParent.name === innermostString),
+    ...(innermostStringParent && ts.isPropertyAssignment(innermostStringParent) && innermostStringParent.name !== innermostString && (ts.isIdentifier(innermostStringParent.name) || ts.isStringLiteral(innermostStringParent.name)) ? {
+      valueOfProperty: innermostStringParent.name.text
+    } : {})
+  };
 }
 
+/** The properties Val computes from a file's bytes. */
+const MEDIA_METADATA_KEYS = ["width", "height", "mimeType"];
 /**
- * Re-find the `c.image(...)` / `c.file(...)` call whose reference argument starts
- * at `refArgStart`, and report where its arguments are *now*.
+ * Re-find the media object literal whose `path` value starts at
+ * `pathValueStart`, and report where its metadata siblings are *now*.
  *
  * `completionItem/resolve` runs against a document the user may have typed into
  * since the list was computed, so the offsets captured back then have moved.
- * Applying them anyway inserts the metadata object into the middle of the string
- * literal and corrupts the file, so the offsets are re-derived here instead.
+ * Applying them anyway inserts text into the middle of the string literal and
+ * corrupts the file, so the offsets are re-derived here instead.
  *
- * Returns `undefined` when no such call is found — the document changed in some
- * way this anchor does not survive, and the caller must then offer no edit
+ * Returns `undefined` when no such object is found — the document changed in
+ * some way this anchor does not survive, and the caller must then offer no edit
  * rather than a wrong one.
  */
-function findFileRefArgument(sourceFile, refArgStart) {
+function findMediaPathObject(sourceFile, pathValueStart) {
   let found;
   function visit(node) {
     if (found) {
       return;
     }
-    if (ts.isCallExpression(node) && fileConstructorSubType(node, sourceFile)) {
-      const [refArg] = node.arguments;
-      if (refArg && ts.isStringLiteralLike(refArg) && refArg.getStart(sourceFile) === refArgStart) {
-        const metadataArg = node.arguments[1];
+    if (ts.isObjectLiteralExpression(node)) {
+      const pathAssignment = node.properties.find(property => ts.isPropertyAssignment(property) && nameOf(property) === "path" && property.initializer.getStart(sourceFile) === pathValueStart);
+      if (pathAssignment) {
+        const existing = {};
+        for (const property of node.properties) {
+          if (!ts.isPropertyAssignment(property)) {
+            continue;
+          }
+          const name = nameOf(property);
+          if (name && MEDIA_METADATA_KEYS.includes(name)) {
+            existing[name] = {
+              start: property.initializer.getStart(sourceFile),
+              end: property.initializer.getEnd()
+            };
+          }
+        }
         found = {
-          refArgEnd: refArg.getEnd(),
-          ...(metadataArg ? {
-            metadataStart: metadataArg.getStart(sourceFile),
-            metadataEnd: metadataArg.getEnd()
-          } : {})
+          insertAfter: pathAssignment.getEnd(),
+          existing
         };
         return;
       }
@@ -1382,22 +2286,18 @@ function findFileRefArgument(sourceFile, refArgStart) {
   visit(sourceFile);
   return found;
 }
-function fileConstructorSubType(node, sourceFile) {
-  if (!ts.isPropertyAccessExpression(node.expression)) {
-    return undefined;
-  }
-  if (node.expression.expression.getText(sourceFile) !== "c") {
-    return undefined;
+function nameOf(property) {
+  if (ts.isIdentifier(property.name) || ts.isStringLiteral(property.name)) {
+    return property.name.text;
   }
-  const name = node.expression.name.getText(sourceFile);
-  return name === "image" || name === "file" ? name : undefined;
+  return undefined;
 }
 
 /**
  * Completions for file and image references.
  *
  * Offers the files that actually exist under the project's files directory, and
- * — when the item is accepted — fills in the metadata argument by reading the
+ * — when the item is accepted — fills in the metadata siblings by reading the
  * chosen file. Getting width/height/mimeType right by hand is tedious and a
  * frequent source of the very validation errors this server reports.
  */
@@ -1416,60 +2316,25 @@ function createValCompletions({
   if (!context) {
     return [];
   }
-  if (context.kind === "string-value") {
-    if (!moduleFilePath || !snapshot) {
-      return [];
-    }
-    return createSchemaDrivenCompletions({
-      document,
-      sourceFile,
-      offset,
-      moduleFilePath,
-      snapshot,
-      files,
-      isPropertyName: context.isPropertyName,
-      valueOfProperty: context.valueOfProperty,
-      contentStart: context.contentStart,
-      contentEnd: context.contentEnd
-    });
+  if (!moduleFilePath || !snapshot) {
+    return [];
   }
-
-  // `c.image()` only accepts images; `c.file()` accepts anything.
-  const candidates = context.subType === "image" ? files.images() : files.list();
-
-  // Replace the whole string contents rather than inserting at the cursor, so
-  // completing over an existing path does not concatenate the two.
-  const replaceRange = {
-    start: document.positionAt(context.contentStart),
-    end: document.positionAt(context.contentEnd)
-  };
-  return candidates.map((file, index) => {
-    const data = {
-      kind: "file-ref",
-      uri: document.uri,
-      ref: file.ref,
-      filePath: file.filePath,
-      subType: context.subType,
-      refArgStart: context.refArgStart
-    };
-    return {
-      label: file.ref,
-      kind: CompletionItemKind.File,
-      detail: file.mimeType,
-      textEdit: {
-        range: replaceRange,
-        newText: file.ref
-      },
-      // Preserve directory ordering rather than letting the client sort
-      // alphabetically on the full path.
-      sortText: String(index).padStart(5, "0"),
-      data
-    };
+  return createSchemaDrivenCompletions({
+    document,
+    sourceFile,
+    offset,
+    moduleFilePath,
+    snapshot,
+    files,
+    isPropertyName: context.isPropertyName,
+    valueOfProperty: context.valueOfProperty,
+    contentStart: context.contentStart,
+    contentEnd: context.contentEnd
   });
 }
 
 /**
- * Fill in the metadata argument for an accepted file reference.
+ * Fill in the metadata siblings for an accepted media path.
  *
  * Done at resolve time because it reads the file from disk, and an editor
  * requests completions far more often than it accepts one.
@@ -1479,7 +2344,13 @@ async function resolveValCompletion({
   documents
 }) {
   const data = item.data;
-  if (data?.kind !== "file-ref") {
+  if (data?.kind !== "media-path") {
+    return item;
+  }
+  // A gallery-backed field stores only the path: its dimensions and mime type
+  // live in the gallery module, and writing them here too is how two copies of
+  // one fact get to disagree.
+  if (data.gallery) {
     return item;
   }
   const document = documents.get(data.uri);
@@ -1487,12 +2358,12 @@ async function resolveValCompletion({
     return item;
   }
 
-  // Re-derive the argument offsets against the document as it is *now*: the user
-  // may have typed to filter the list since it was computed, which moves
-  // everything after the reference string. `additionalTextEdits` are applied
-  // verbatim by the client, so a stale offset here corrupts the file.
-  const args = findFileRefArgument(ts.createSourceFile(data.uri, document.getText(), ts.ScriptTarget.ES2020, false, ts.ScriptKind.TS), data.refArgStart);
-  if (!args) {
+  // Re-derive the offsets against the document as it is *now*: the user may
+  // have typed to filter the list since it was computed, which moves everything
+  // after the path string. `additionalTextEdits` are applied verbatim by the
+  // client, so a stale offset here corrupts the file.
+  const object = findMediaPathObject(ts.createSourceFile(data.uri, document.getText(), ts.ScriptTarget.ES2020, false, ts.ScriptKind.TS), data.pathValueStart);
+  if (!object) {
     // The anchor no longer resolves, so there is no safe place to put the
     // metadata. `val validate --fix` and the metadata quick fix still cover it.
     return item;
@@ -1501,24 +2372,43 @@ async function resolveValCompletion({
   if (!metadata) {
     return item;
   }
-  const edit = args.metadataStart !== undefined && args.metadataEnd !== undefined ? {
-    // Replace an existing metadata argument.
-    range: {
-      start: document.positionAt(args.metadataStart),
-      end: document.positionAt(args.metadataEnd)
-    },
-    newText: metadata
-  } : {
-    // Insert one after the reference argument.
-    range: {
-      start: document.positionAt(args.refArgEnd),
-      end: document.positionAt(args.refArgEnd)
-    },
-    newText: `, ${metadata}`
-  };
+  const edits = [];
+  const missing = [];
+  for (const key of MEDIA_METADATA_KEYS) {
+    const value = metadata[key];
+    if (value === undefined) {
+      continue;
+    }
+    const at = object.existing[key];
+    if (at) {
+      edits.push({
+        range: {
+          start: document.positionAt(at.start),
+          end: document.positionAt(at.end)
+        },
+        newText: value
+      });
+    } else {
+      missing.push(`${key}: ${value}`);
+    }
+  }
+  if (missing.length > 0) {
+    // One insertion after the `path` property, so the edits stay disjoint —
+    // a client applies them verbatim and two overlapping ranges corrupt the file.
+    edits.push({
+      range: {
+        start: document.positionAt(object.insertAfter),
+        end: document.positionAt(object.insertAfter)
+      },
+      newText: `, ${missing.join(", ")}`
+    });
+  }
+  if (edits.length === 0) {
+    return item;
+  }
   return {
     ...item,
-    additionalTextEdits: [edit]
+    additionalTextEdits: edits
   };
 }
 
@@ -1531,18 +2421,24 @@ async function resolveValCompletion({
 async function readMetadata(data) {
   try {
     const buffer = fs.readFileSync(data.filePath);
-    if (data.subType === "image") {
+    if (data.mediaType === "image") {
       const metadata = await extractImageMetadata(data.filePath, buffer);
       if (metadata.width === undefined || metadata.height === undefined || !metadata.mimeType) {
         return undefined;
       }
-      return `{ width: ${metadata.width}, height: ${metadata.height}, mimeType: ${JSON.stringify(metadata.mimeType)} }`;
+      return {
+        width: String(metadata.width),
+        height: String(metadata.height),
+        mimeType: JSON.stringify(metadata.mimeType)
+      };
     }
     const metadata = await extractFileMetadata(data.filePath, buffer);
     if (!metadata.mimeType) {
       return undefined;
     }
-    return `{ mimeType: ${JSON.stringify(metadata.mimeType)} }`;
+    return {
+      mimeType: JSON.stringify(metadata.mimeType)
+    };
   } catch {
     // An unreadable or unrecognised file just means no metadata to offer.
     return undefined;
@@ -1601,6 +2497,27 @@ function createSchemaDrivenCompletions({
     const galleryFiles = container.mediaType === "images" ? files.images(directory) : files.list(directory);
     return items(galleryFiles.map(file => file.ref), CompletionItemKind.File, range);
   }
+
+  // Media is an object literal with a `path`, so the cursor's own module path is
+  // `…."image"."path"` — resolving that would try to descend INTO the image
+  // schema. The container is what says whether this is media at all, and which
+  // kind, and which directory its files come from. Before this was an object,
+  // the callee name (`c.image` vs `c.file`) said so, and per-field `directory`
+  // was ignored.
+  if (!isPropertyName && valueOfProperty === "path") {
+    const container = resolveSchemaAt(parentModulePath(modulePath), source, schema);
+    if (container && typeof container === "object" && "type" in container && (container.type === "image" || container.type === "file")) {
+      return mediaPathItems({
+        document,
+        container,
+        snapshot,
+        files,
+        range,
+        contentStart
+      });
+    }
+    return [];
+  }
   const fieldSchema = resolveSchemaAt(modulePath, source, schema);
 
   // Checked before the schema is required, because Val describes richtext content
@@ -1626,6 +2543,58 @@ function createSchemaDrivenCompletions({
   return [];
 }
 
+/**
+ * The files a media field can point at, as completion items.
+ *
+ * Where they come from, in order: the field's own `directory`, then the
+ * directory of the gallery it references, then the default.
+ */
+function mediaPathItems({
+  document,
+  container,
+  snapshot,
+  files,
+  range,
+  contentStart
+}) {
+  const referencedModule = typeof container.referencedModule === "string" ? container.referencedModule : undefined;
+  const options = container.options;
+  let directory = typeof options?.directory === "string" ? options.directory : undefined;
+  if (directory === undefined && referencedModule) {
+    const gallery = snapshot.schemas[referencedModule];
+    if (gallery?.type === "record" && typeof gallery.directory === "string") {
+      directory = gallery.directory;
+    }
+  }
+  const candidates = container.type === "image" ? files.images(directory) : files.list(directory);
+  return candidates.map((file, index) => {
+    const data = {
+      kind: "media-path",
+      uri: document.uri,
+      ref: file.ref,
+      filePath: file.filePath,
+      mediaType: container.type,
+      gallery: referencedModule !== undefined,
+      pathValueStart: contentStart - 1
+    };
+    return {
+      label: file.ref,
+      kind: CompletionItemKind.File,
+      detail: file.mimeType,
+      // Replace the whole string contents rather than inserting at the cursor,
+      // so completing over an existing path does not concatenate the two.
+      textEdit: {
+        range,
+        newText: file.ref
+      },
+      // Preserve directory ordering rather than letting the client sort
+      // alphabetically on the full path.
+      sortText: String(index).padStart(5, "0"),
+      data
+    };
+  });
+}
+
 /** The routes the project defines, as completion items. */
 function routeItems(snapshot, range) {
   // The routes that exist are the keys of the project's router modules, which is
@@ -1679,57 +2648,306 @@ function permitsInlineLinks(richtext) {
   return Boolean(options?.inline?.a);
 }
 
-/** Schema at a module path, or undefined when it cannot be resolved. */
-function resolveSchemaAt(modulePath, source, schema) {
+/** Schema at a module path, or undefined when it cannot be resolved. */
+function resolveSchemaAt(modulePath, source, schema) {
+  try {
+    // Val's own resolver, rather than a hand-rolled serialized-schema walker.
+    return Internal.resolvePath(modulePath, source, schema).schema;
+  } catch {
+    return undefined;
+  }
+}
+
+/** Drop the last segment of a module path; `""` is the module root. */
+function parentModulePath(modulePath) {
+  const segments = Internal.splitModulePath(modulePath);
+  return Internal.patchPathToModulePath(segments.slice(0, -1));
+}
+function items(labels, kind, range) {
+  return labels.map((label, index) => ({
+    label,
+    kind,
+    textEdit: {
+      range,
+      newText: label
+    },
+    // Preserve the source ordering rather than letting the client re-sort.
+    sortText: String(index).padStart(5, "0")
+  }));
+}
+function keysOfKeyOf(schema, snapshot) {
+  // Object targets serialize their keys directly.
+  if (Array.isArray(schema.values)) {
+    return schema.values;
+  }
+  // Record targets say "string"; the keys are whatever the target module holds.
+  if (!schema.path) {
+    return [];
+  }
+  try {
+    const [targetModuleFilePath, targetModulePath] = Internal.splitModuleFilePathAndModulePath(schema.path);
+    const targetSchema = snapshot.schemas[targetModuleFilePath];
+    const targetSource = snapshot.sources[targetModuleFilePath];
+    if (!targetSchema || targetSource === undefined) {
+      return [];
+    }
+    const resolved = Internal.resolvePath(targetModulePath, targetSource, targetSchema);
+    const value = resolved.source;
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+      return [];
+    }
+    return Object.keys(value);
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * The two remedies for a gallery-backed field pointing at something its gallery
+ * does not have.
+ *
+ * Core reports the problem (`packages/core/src/schema/image.ts`) and offers no
+ * `ValidationFix`, because neither remedy is a change to the module holding the
+ * field:
+ *
+ *  - **register it** — add an entry to the *gallery* module, keyed by the path,
+ *    carrying the metadata read from the file. An edit to another document.
+ *  - **move the file** — when the file is on disk but outside the gallery's
+ *    directory, move it there and update the path. A file rename plus an edit.
+ *
+ * Both used to be VS Code commands in the extension, driven by diagnostics the
+ * extension computed itself. They are here so that every editor gets them, and
+ * so that a change to how galleries work has one place to be reflected.
+ */
+
+/**
+ * Whether the client will honour a file rename inside a `WorkspaceEdit`.
+ *
+ * A `RenameFile` sent to a client that did not announce `resourceOperations`
+ * is silently dropped, which would leave the path rewritten and the file where it
+ * 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");
+}
+async function createGalleryMembershipActions({
+  document,
+  gallery,
+  valRoot,
+  read,
+  allowRename
+}) {
+  const actions = [];
+  const absolute = path.join(valRoot, gallery.path);
+  const onDisk = fs.existsSync(absolute);
+  const register = await createRegisterInGalleryAction({
+    gallery,
+    valRoot,
+    read,
+    onDisk
+  });
+  if (register) {
+    actions.push(register);
+  }
+  if (allowRename && gallery.directory && onDisk) {
+    const move = createMoveIntoGalleryDirectoryAction({
+      document,
+      gallery,
+      valRoot
+    });
+    if (move) {
+      actions.push(move);
+    }
+  }
+  return actions;
+}
+
+/** Add `"<path>": { …metadata }` to the gallery module's record. */
+async function createRegisterInGalleryAction({
+  gallery,
+  valRoot,
+  read,
+  onDisk
+}) {
+  if (!onDisk) {
+    // Registering a path with no file behind it would trade this diagnostic for
+    // a "file does not exist" one.
+    return undefined;
+  }
+  if (gallery.directory && !gallery.path.startsWith(`${gallery.directory}/`)) {
+    // Outside the gallery's directory: registering it would break the gallery's
+    // own directory check. Moving is the remedy, not registering.
+    return undefined;
+  }
+  const galleryFile = path.join(valRoot, gallery.referencedModule);
+  const text = read(galleryFile) ?? readFileOrUndefined(galleryFile);
+  if (text === undefined) {
+    return undefined;
+  }
+  const sourceFile = ts.createSourceFile(galleryFile, text, ts.ScriptTarget.ES2020, true);
+  const insertion = findRecordInsertion(sourceFile);
+  if (!insertion) {
+    return undefined;
+  }
+  const metadata = await readMetadataSource(path.join(valRoot, gallery.path), gallery.mediaType);
+  if (!metadata) {
+    return undefined;
+  }
+  const position = sourceFile.getLineAndCharacterOfPosition(insertion.insertOffset);
+  const entry = `${JSON.stringify(gallery.path)}: { ${metadata} }`;
+  const edit = {
+    range: {
+      start: position,
+      end: position
+    },
+    newText: insertion.hasProperties ? `,\n${insertion.indentation}${entry}` : `\n${insertion.indentation}${entry}\n${insertion.indentation.slice(2)}`
+  };
+  return CodeAction.create(`Val: add ${path.posix.basename(gallery.path)} to the gallery`, {
+    changes: {
+      [pathToUri(galleryFile)]: [edit]
+    }
+  }, CodeActionKind.QuickFix);
+}
+
+/** Move the file into the gallery's directory, and point the field at it. */
+function createMoveIntoGalleryDirectoryAction({
+  document,
+  gallery,
+  valRoot
+}) {
+  const directory = gallery.directory;
+  if (!directory || gallery.path.startsWith(`${directory}/`)) {
+    return undefined;
+  }
+  const target = `${directory}/${path.posix.basename(gallery.path)}`;
+  if (fs.existsSync(path.join(valRoot, target))) {
+    // Something already lives there. Overwriting a different file is not a fix.
+    return undefined;
+  }
+  const range = findPathStringRange(document, gallery.path);
+  if (!range) {
+    return undefined;
+  }
+  return {
+    title: `Val: move ${path.posix.basename(gallery.path)} into ${directory}`,
+    kind: CodeActionKind.QuickFix,
+    edit: {
+      documentChanges: [{
+        kind: "rename",
+        oldUri: pathToUri(path.join(valRoot, gallery.path)),
+        newUri: pathToUri(path.join(valRoot, target))
+      }, {
+        textDocument: {
+          uri: document.uri,
+          version: null
+        },
+        edits: [{
+          range,
+          newText: target
+        }]
+      }]
+    }
+  };
+}
+
+/**
+ * The range of the `path` string's *contents* in the field being fixed.
+ *
+ * Located by searching the document text for the path in quotes rather than
+ * through the module path map: the map addresses the value, and what has to be
+ * replaced is the text inside the quotes.
+ */
+function findPathStringRange(document, currentPath) {
+  const text = document.getText();
+  for (const quote of ['"', "'"]) {
+    const needle = `${quote}${currentPath}${quote}`;
+    const at = text.indexOf(needle);
+    if (at === -1) {
+      continue;
+    }
+    // A second occurrence means we cannot tell which one the diagnostic is
+    // about, and rewriting the wrong one is worse than offering nothing.
+    if (text.indexOf(needle, at + 1) !== -1) {
+      return undefined;
+    }
+    return {
+      start: document.positionAt(at + 1),
+      end: document.positionAt(at + 1 + currentPath.length)
+    };
+  }
+  return undefined;
+}
+
+/**
+ * Where to insert into the record that is a gallery module's content -- the third
+ * argument of its `c.define(...)`.
+ */
+function findRecordInsertion(sourceFile) {
+  let found = null;
+  function visit(node) {
+    if (found === null && ts.isCallExpression(node) && ts.isPropertyAccessExpression(node.expression) && node.expression.name.text === "define" && node.arguments.length >= 3) {
+      const record = node.arguments[2];
+      if (ts.isObjectLiteralExpression(record)) {
+        if (record.properties.length > 0) {
+          const last = record.properties[record.properties.length - 1];
+          const first = record.properties[0];
+          const {
+            character
+          } = sourceFile.getLineAndCharacterOfPosition(first.getStart(sourceFile));
+          found = {
+            insertOffset: last.end,
+            indentation: " ".repeat(character),
+            hasProperties: true
+          };
+        } else {
+          found = {
+            insertOffset: record.getStart(sourceFile) + 1,
+            indentation: "    ",
+            hasProperties: false
+          };
+        }
+        return;
+      }
+    }
+    ts.forEachChild(node, visit);
+  }
+  visit(sourceFile);
+  return found;
+}
+
+/**
+ * The metadata for a gallery entry, rendered as source.
+ *
+ * Read with `@valbuild/server`'s extractors -- the same ones `val validate --fix`
+ * and the media-path completion use -- so a registered entry and a fixed one
+ * agree. `alt: null` matches what an upload writes.
+ */
+async function readMetadataSource(filePath, mediaType) {
   try {
-    // Val's own resolver, rather than a hand-rolled serialized-schema walker.
-    return Internal.resolvePath(modulePath, source, schema).schema;
+    const buffer = fs.readFileSync(filePath);
+    if (mediaType === "image") {
+      const metadata = await extractImageMetadata(filePath, buffer);
+      if (metadata.width === undefined || metadata.height === undefined || !metadata.mimeType) {
+        return undefined;
+      }
+      return `width: ${metadata.width}, height: ${metadata.height}, mimeType: ${JSON.stringify(metadata.mimeType)}, alt: null`;
+    }
+    const metadata = await extractFileMetadata(filePath, buffer);
+    if (!metadata.mimeType) {
+      return undefined;
+    }
+    return `mimeType: ${JSON.stringify(metadata.mimeType)}`;
   } catch {
     return undefined;
   }
 }
-
-/** Drop the last segment of a module path; `""` is the module root. */
-function parentModulePath(modulePath) {
-  const segments = Internal.splitModulePath(modulePath);
-  return Internal.patchPathToModulePath(segments.slice(0, -1));
-}
-function items(labels, kind, range) {
-  return labels.map((label, index) => ({
-    label,
-    kind,
-    textEdit: {
-      range,
-      newText: label
-    },
-    // Preserve the source ordering rather than letting the client re-sort.
-    sortText: String(index).padStart(5, "0")
-  }));
-}
-function keysOfKeyOf(schema, snapshot) {
-  // Object targets serialize their keys directly.
-  if (Array.isArray(schema.values)) {
-    return schema.values;
-  }
-  // Record targets say "string"; the keys are whatever the target module holds.
-  if (!schema.path) {
-    return [];
-  }
+function readFileOrUndefined(filePath) {
   try {
-    const [targetModuleFilePath, targetModulePath] = Internal.splitModuleFilePathAndModulePath(schema.path);
-    const targetSchema = snapshot.schemas[targetModuleFilePath];
-    const targetSource = snapshot.sources[targetModuleFilePath];
-    if (!targetSchema || targetSource === undefined) {
-      return [];
-    }
-    const resolved = Internal.resolvePath(targetModulePath, targetSource, targetSchema);
-    const value = resolved.source;
-    if (!value || typeof value !== "object" || Array.isArray(value)) {
-      return [];
-    }
-    return Object.keys(value);
+    return fs.readFileSync(filePath, "utf8");
   } catch {
-    return [];
+    return undefined;
   }
 }
 
@@ -1818,148 +3036,6 @@ function createPublicValFiles({
   };
 }
 
-/**
- * Works out which Val modules a `val.modules.{ts,js}` file registers.
- *
- * Val only serves modules listed there, so an unregistered `.val.ts` file
- * silently does nothing.
- *
- * Rather than pattern-matching the accepted authoring shapes — `config.modules([…])`
- * vs `modules(config, […])`, bare `import("./x.val")` vs
- * `{ def: () => import("./x.val") }` — this collects *every* dynamic import
- * specifier in the file. That is deliberate:
- *
- *  - it covers all current shapes with one rule, and any shape added later;
- *  - when in doubt it over-reports registration, so a new authoring form makes
- *    the diagnostic go quiet rather than firing a false "missing module" on
- *    every file, which is the failure mode that actually hurts.
- */
-function findRegisteredModuleSpecifiers(sourceFile) {
-  const specifiers = [];
-  function visit(node) {
-    if (ts.isCallExpression(node) && node.expression.kind === ts.SyntaxKind.ImportKeyword) {
-      const [arg] = node.arguments;
-      if (arg && ts.isStringLiteralLike(arg)) {
-        specifiers.push(arg.text);
-      }
-    }
-    ts.forEachChild(node, visit);
-  }
-  visit(sourceFile);
-  return specifiers;
-}
-
-/**
- * Whether `moduleFilePath` is registered by the given `val.modules` file.
- *
- * @param valModulesDir directory containing the val.modules file, relative to
- *   the Val root (`""` when it sits at the root).
- * @param moduleFilePath the module's path, Val-style: root-relative, leading
- *   slash, with extension (for example `/content/page.val.ts`).
- */
-function isModuleRegistered({
-  sourceFile,
-  valModulesDir,
-  moduleFilePath
-}) {
-  const target = stripValModuleExtension(moduleFilePath);
-  return findRegisteredModuleSpecifiers(sourceFile).some(specifier => {
-    // Specifiers are written relative to the val.modules file and normally omit
-    // the extension ("./content/page.val").
-    const resolved = specifier.startsWith(".") ? path.posix.normalize(path.posix.join("/", valModulesDir, stripValModuleExtension(specifier))) : stripValModuleExtension(specifier);
-    return resolved === target;
-  });
-}
-
-/** `/content/page.val.ts` -> `/content/page.val` (also handles `.val` already). */
-function stripValModuleExtension(specifier) {
-  return specifier.replace(/\.val\.(ts|js|tsx|jsx)$/, ".val");
-}
-
-/**
- * Conversions between LSP document URIs and the paths Val uses.
- *
- * Deliberately minimal rather than pulling in `vscode-uri`: the server only ever
- * deals with local `file:` URIs, and keeping this small makes the assumptions
- * visible.
- */
-
-/** Matches the Val module files the server validates. */
-const VAL_MODULE_RE = /\.val\.(ts|js|tsx|jsx)$/;
-
-/** `file:` with an optional authority, capturing authority and path apart. */
-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]:)(\/|$)/;
-function isValModuleUri(uri) {
-  return VAL_MODULE_RE.test(uri);
-}
-
-/**
- * `decodeURIComponent` throws on malformed escapes (`%zz`). A client that sends
- * one is broken, but that should not take the server down: fall back to the
- * undecoded text so the path is at worst not found.
- */
-function decodeSafely(value) {
-  try {
-    return decodeURIComponent(value);
-  } catch {
-    return value;
-  }
-}
-
-/**
- * `file:///a/b.val.ts` -> `/a/b.val.ts`
- *
- * Percent escapes are decoded, Windows drive letters lose the leading slash
- * (`file:///c%3A/a` -> `c:/a`), and a URI with an authority is read as a UNC
- * path (`file://host/share/a` -> `//host/share/a`). Anything that is not a
- * `file:` URI is passed through unchanged, since callers also hand us plain
- * paths.
- */
-function uriToPath(uri) {
-  const match = FILE_URI_RE.exec(uri);
-  if (!match) {
-    return uri;
-  }
-  const authority = decodeSafely(match[1]);
-  const fsPath = decodeSafely(match[2] || "/");
-  if (authority) {
-    return `//${authority}${fsPath}`;
-  }
-  return fsPath.replace(URI_DRIVE_LETTER_RE, "$1$2");
-}
-
-/**
- * `/a/b.val.ts` -> `file:///a/b.val.ts`
- *
- * The escaping matches what VS Code produces (drive-letter colons included), so
- * that a URI built here can be looked up in the open-document map keyed by the
- * URIs the client sent.
- */
-function pathToUri(fsPath) {
-  const normalized = fsPath.split(path.sep).join("/");
-  const rooted = normalized.startsWith("/") ? normalized : `/${normalized}`;
-  return `file://${rooted.split("/").map(segment => encodeURIComponent(segment)).join("/")}`;
-}
-
-/**
- * Convert a document URI into the `ModuleFilePath` Val addresses it by: a
- * POSIX-style path relative to the Val root, with a leading slash.
- *
- * Returns `undefined` when the file lies outside the Val root — one server
- * serves exactly one root, so another root's files are not its business.
- */
-function toModuleFilePath(valRoot, uri) {
-  const fsPath = uriToPath(uri);
-  const relative = path.relative(valRoot, fsPath);
-  if (!relative || relative.startsWith("..") || path.isAbsolute(relative)) {
-    return undefined;
-  }
-  return `/${relative.split(path.sep).join("/")}`;
-}
-
 /**
  * How long to wait after an edit before re-evaluating.
  *
@@ -2125,6 +3201,8 @@ function findMissingModuleDiagnostic(valRoot, moduleFilePath, read) {
  */
 function createValLanguageServer(connection) {
   const documents = new TextDocuments(TextDocument);
+  let canRegisterWatchers = false;
+  let canRenameFiles$1 = false;
 
   /**
    * The editor's view of a file, by absolute path, or `undefined` when the file
@@ -2198,6 +3276,23 @@ function createValLanguageServer(connection) {
       // Needed to resolve keyOf/route validation, which has to look at other
       // modules. Built once and refreshed per changed module.
       const snapshotResult = await project.getSnapshot();
+      // Core attaches the gallery checks to every gallery module whether or not
+      // anything is wrong, so they have to be adjudicated by the same fix
+      // handlers `val validate` uses before any of them is shown.
+      // Narrowed once: `project` is module-level and reassigned on shutdown, so
+      // the closures below need a local binding.
+      const activeProject = project;
+      const galleryChecks = result.content.errors !== false && result.content.errors.validation ? await resolveGalleryChecks({
+        validation: result.content.errors.validation,
+        runHandler: (sourcePath, validationError) => adjudicateGalleryCheck({
+          sourcePath,
+          validationError,
+          moduleFilePath,
+          valRoot: activeProject.valRoot,
+          content: result.content,
+          runFixHandler: args => activeProject.runFixHandler(args)
+        })
+      }) : undefined;
       const diagnostics = createValDiagnostics({
         moduleFilePath,
         content: result.content,
@@ -2205,6 +3300,9 @@ function createValLanguageServer(connection) {
         valRoot: project.valRoot,
         ...(snapshotResult.status === "ok" ? {
           snapshot: snapshotResult.snapshot
+        } : {}),
+        ...(galleryChecks ? {
+          galleryChecks
         } : {})
       });
       const unregistered = findMissingModuleDiagnostic(project.valRoot, moduleFilePath, readOpenDocument);
@@ -2248,13 +3346,22 @@ function createValLanguageServer(connection) {
         }
       };
     }
+
+    // Whether we may ask the client to watch files for us, rather than relying on
+    // it having been configured to. A VS Code extension can set watchers up
+    // itself; a hand-written Neovim config generally will not, and this is what
+    // makes the server work the same in both.
+    canRegisterWatchers = params.capabilities.workspace?.didChangeWatchedFiles?.dynamicRegistration === true;
+    // 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);
     const clientCapabilities = params.capabilities.experimental?.val ?? {};
 
     // Announce only what this version actually serves: a client hides UI for
     // anything missing here, and ignores anything it does not recognise.
     // Completions and commands land in later phases.
-    const features = ["diagnostics", "fix/metadata", "completions/mediaPath", "completions/keyOf", "completions/route", "fix/gallery", "completions/galleryKey", "completions/richtextLink"];
-    const commands = [];
+    const features = ["diagnostics", "fix/metadata", "completions/mediaPath", "completions/keyOf", "completions/route", "fix/gallery", "completions/galleryKey", "completions/richtextLink", "fix/missing-module", "fix/upload-remote", "fix/download-remote", "login", "diagnostics/gallery"];
+    const commands = valCommandNames();
     publicFiles = createPublicValFiles({
       valRoot: options.valRoot
     });
@@ -2318,6 +3425,45 @@ function createValLanguageServer(connection) {
       }
     };
   });
+  const commandHandlers = createValCommands({
+    connection,
+    getProject: () => project,
+    getDocument: uri => documents.get(uri)
+  });
+  connection.onExecuteCommand(async params => {
+    try {
+      await commandHandlers.execute(params.command, params.arguments ?? []);
+    } catch (e) {
+      // A command that throws must not take the server down with it.
+      connection.console.error(`Val: ${params.command} failed: ${e instanceof Error ? e.message : String(e)}`);
+    }
+  });
+  connection.onInitialized(() => {
+    if (!canRegisterWatchers) {
+      return;
+    }
+    // Registered here rather than in `initialize`: dynamic registration is a
+    // request to the client, and the client is not ready to answer one until it
+    // has sent `initialized`.
+    void connection.client.register(DidChangeWatchedFilesNotification.type, {
+      watchers: [{
+        globPattern: "**/*.val.{ts,js}"
+      }, {
+        globPattern: "**/val.modules.{ts,js}"
+      }, {
+        globPattern: "**/val.config.{ts,js}"
+      },
+      // Media completions and file-not-found diagnostics both read this
+      // tree, and nothing else tells us a file arrived in it.
+      {
+        globPattern: "**/public/**"
+      }]
+    }).catch(e => {
+      // A client that declined leaves us on document events alone, which is
+      // what every client did before this existed.
+      connection.console.warn(`Val: could not register file watchers: ${e instanceof Error ? e.message : String(e)}`);
+    });
+  });
   connection.onCompletion(async params => {
     const document = documents.get(params.textDocument.uri);
     if (!publicFiles || !project || !document || !isValModuleUri(params.textDocument.uri)) {
@@ -2367,16 +3513,51 @@ function createValLanguageServer(connection) {
       return [];
     }
     try {
+      const actions = [];
+
+      // Registering a module in val.modules is not a content fix, so it is not
+      // part of the createFixPatch pipeline: it is offered whenever the
+      // diagnostic is present, even if the module could not be evaluated -- a
+      // module Val does not serve is exactly the kind that fails to evaluate.
+      const unregistered = params.context.diagnostics.some(diagnostic => diagnostic.data?.code === "val/missing-module");
+      if (unregistered) {
+        const action = createMissingModuleCodeAction({
+          valRoot: project.valRoot,
+          moduleFilePath,
+          read: readOpenDocument
+        });
+        if (action) {
+          actions.push(action);
+        }
+      }
       const result = await project.getModule(moduleFilePath);
       if (result.status === "error") {
-        return [];
+        return actions;
+      }
+
+      // Gallery membership: core reports it but offers no fix, because both
+      // remedies are edits elsewhere -- the gallery module, or the file itself.
+      for (const diagnostic of params.context.diagnostics) {
+        const data = diagnostic.data;
+        if (data?.code !== "val/gallery-membership" || !data.gallery) {
+          continue;
+        }
+        actions.push(...(await createGalleryMembershipActions({
+          document,
+          gallery: data.gallery,
+          valRoot: project.valRoot,
+          read: readOpenDocument,
+          allowRename: canRenameFiles$1
+        })));
       }
-      return await createValCodeActions({
+      actions.push(...(await createValCodeActions({
         document,
         diagnostics: params.context.diagnostics,
         content: result.content,
-        valRoot: project.valRoot
-      });
+        valRoot: project.valRoot,
+        moduleFilePath
+      })));
+      return actions;
     } catch (e) {
       connection.console.error(`Val: failed to build code actions for ${params.textDocument.uri}: ${e instanceof Error ? e.message : String(e)}`);
       return [];
@@ -2405,6 +3586,69 @@ function createValLanguageServer(connection) {
     }
     scheduleValidation(document.uri);
   });
+
+  /**
+   * React to changes made outside the editor's buffers.
+   *
+   * `didChange` covers what the user types; it says nothing about a `git
+   * checkout`, a `val validate --fix` run in a terminal, or an image dropped
+   * into `/public/val`. Without this the server kept serving a stale evaluation
+   * and stale completion candidates until something happened to be retyped —
+   * and the watchers an editor had already been told to send were feeding a
+   * handler that did not exist.
+   */
+  connection.onDidChangeWatchedFiles(({
+    changes
+  }) => {
+    if (!project) {
+      return;
+    }
+    let projectWide = false;
+    const changed = [];
+    for (const change of changes) {
+      const fsPath = uriToPath(change.uri);
+      if (fsPath === null) {
+        continue;
+      }
+      if (PROJECT_WIDE_FILE_RE.test(fsPath)) {
+        projectWide = true;
+        continue;
+      }
+      // A file appearing or vanishing under the files directory changes what a
+      // media path may complete to.
+      publicFiles?.invalidate();
+      if (!isValModuleUri(change.uri)) {
+        continue;
+      }
+      const moduleFilePath = toModuleFilePath(project.valRoot, change.uri);
+      if (moduleFilePath) {
+        changed.push(moduleFilePath);
+      }
+    }
+    if (projectWide) {
+      project.invalidate();
+      publicFiles?.invalidate();
+      for (const open of documents.all()) {
+        if (isValModuleUri(open.uri)) {
+          scheduleValidation(open.uri);
+        }
+      }
+      return;
+    }
+    for (const moduleFilePath of changed) {
+      project.invalidate(moduleFilePath);
+    }
+    // A module the user is not looking at can still be the one that makes an
+    // open module invalid -- a gallery it references, a record a keyOf points
+    // at -- so revalidate every open module rather than only the changed ones.
+    if (changed.length > 0) {
+      for (const open of documents.all()) {
+        if (isValModuleUri(open.uri)) {
+          scheduleValidation(open.uri);
+        }
+      }
+    }
+  });
   documents.onDidClose(({
     document
   }) => {
@@ -2448,4 +3692,4 @@ function main() {
   createValLanguageServer(createConnection(ProposedFeatures.all));
 }
 
-export { DEFAULT_FILES_DIRECTORY, PROTOCOL_VERSION, SUPPORTED_PROTOCOL_VERSIONS, VAL_DIAGNOSTIC_CODES, VAL_DIAGNOSTIC_SOURCE, VAL_FEATURES, VAL_INPUT_REQUEST, VAL_PICK_REQUEST, createEditorFsHost, createMissingModuleDiagnostic, createModulePathMap, createProjectErrorDiagnostic, createPublicValFiles, createValCodeActions, createValCompletions, createValDiagnostics, createValLanguageServer, createValProject, defaultCoreResolver, findModulePathAtPosition, findRegisteredModuleSpecifiers, getLanguageServerVersion, getModulePathRange, getValCompletionContext, isLocalFix, isModuleRegistered, isValModuleUri, main, mapOpenDocuments, minimalTextEdit, negotiateProtocolVersion, pathToUri, resolveValCompletion, severityFor, toModuleFilePath, uriToPath };
+export { DEFAULT_FILES_DIRECTORY, MEDIA_METADATA_KEYS, PROTOCOL_VERSION, REMOTE_FIX_COMMANDS, REMOTE_FIX_TITLES, SUPPORTED_PROTOCOL_VERSIONS, VAL_DIAGNOSTIC_CODES, VAL_DIAGNOSTIC_SOURCE, VAL_DOWNLOAD_REMOTE_COMMAND, VAL_FEATURES, VAL_INPUT_REQUEST, VAL_LOGIN_COMMAND, VAL_PICK_REQUEST, VAL_UPLOAD_REMOTE_COMMAND, adjudicateGalleryCheck, canRenameFiles, createEditorFsHost, createGalleryMembershipActions, createMissingModuleCodeAction, createMissingModuleDiagnostic, createModulePathMap, createProjectErrorDiagnostic, createPublicValFiles, createValCodeActions, createValCommands, createValCompletions, createValDiagnostics, createValLanguageServer, createValProject, defaultCoreResolver, findMediaPathObject, findModulePathAtPosition, findRecordInsertion, findRegisteredModuleSpecifiers, findValModulesInsertion, galleryCheckKey, galleryMembershipAt, getLanguageServerVersion, getModulePathRange, getValCompletionContext, isGalleryCheckFix, isLocalFix, isModuleRegistered, isRemoteFix, isValModuleUri, main, mapOpenDocuments, minimalTextEdit, negotiateProtocolVersion, pathToUri, readPersonalAccessToken, resolveGalleryChecks, resolveValCompletion, severityFor, toModuleFilePath, uriToPath, valCommandNames, valModuleSpecifier, valModulesEntryText };