@valbuild/language-server 0.124.0 → 0.125.0

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

@@ -170,22 +170,71 @@ function negotiateProtocolVersion(client, server = SUPPORTED_PROTOCOL_VERSIONS)
   };
 }
 
+var packageJson = {
+	name: "@valbuild/language-server",
+	"private": false,
+	description: "Val - editor language server (LSP)",
+	repository: {
+		type: "git",
+		url: "git+https://github.com/valbuild/val.git"
+	},
+	keywords: [
+		"CMS",
+		"lsp",
+		"language-server"
+	],
+	version: "0.125.0",
+	bin: {
+		"val-language-server": "./bin.js"
+	},
+	main: "dist/valbuild-language-server.cjs.js",
+	module: "dist/valbuild-language-server.esm.js",
+	exports: {
+		".": {
+			module: "./dist/valbuild-language-server.esm.js",
+			"default": "./dist/valbuild-language-server.cjs.js"
+		},
+		"./package.json": "./package.json"
+	},
+	types: "dist/valbuild-language-server.cjs.d.ts",
+	scripts: {
+		typecheck: "tsc --noEmit",
+		test: "jest",
+		"test:watch": "jest --watch",
+		bench: "node scripts/evalLatency.bench.js"
+	},
+	dependencies: {
+		"@valbuild/core": "workspace:*",
+		"@valbuild/server": "workspace:*",
+		"@valbuild/shared": "workspace:*",
+		typescript: "^6.0.3",
+		"vscode-languageserver": "^10.1.0",
+		"vscode-languageserver-textdocument": "^1.0.14"
+	},
+	devDependencies: {
+		"@types/jest": "^30.0.0",
+		"vscode-jsonrpc": "^9.0.2"
+	},
+	engines: {
+		node: "^20.19.0 || >=22"
+	},
+	files: [
+		"CHANGELOG.md",
+		"dist",
+		"bin.js",
+		"README.md"
+	]
+};
+
 /**
- * Version of this package, read from its own package.json.
+ * This package's version, inlined at build time.
  *
- * Mirrors how `@valbuild/core` reports `Internal.VERSION.core`
- * (see `packages/core/src/index.ts`): the built output lives one directory
- * below the package root, so `../package.json` resolves correctly. Returns
- * `null` rather than throwing if the file cannot be read — the version is only
- * ever used for display, never for behaviour.
+ * See `packages/core/src/index.ts` for why this is a static JSON import rather
+ * than `require("../package.json")`. The version is only ever displayed here,
+ * but the two should not drift apart in how they read it.
  */
 function getLanguageServerVersion() {
-  try {
-    // eslint-disable-next-line @typescript-eslint/no-require-imports
-    return require("../package.json").version;
-  } catch {
-    return null;
-  }
+  return packageJson.version ;
 }
 
 /**
@@ -858,19 +907,28 @@ function traverseObjectLiteral(node, sourceFile) {
 }
 
 /**
- * Adjudicating the media metadata placeholders core emits unconditionally.
+ * Adjudicating the media placeholders core emits unconditionally.
+ *
+ * A media schema cannot answer two of its own questions, because both need
+ * something core has no access to -- the bytes on disk, or the bytes on the
+ * content host. So it defers, by reporting an error that only means "nobody
+ * has looked yet":
  *
- * `ImageSchema.validate` cannot read bytes, so it never answers "does the
- * stored width/height/mimeType match the file". It defers instead: any
- * `s.image()` carrying metadata gets an `image:check-metadata` error whether
- * or not anything is wrong (`packages/core/src/schema/image.ts`), and
- * `s.file()` does the same with `file:check-metadata`.
+ *  - **Metadata.** Any `s.image()` carrying metadata gets an
+ *    `image:check-metadata` error whether or not anything is wrong
+ *    (`packages/core/src/schema/image.ts`), and `s.file()` does the same with
+ *    `file:check-metadata`.
+ *  - **Remote refs.** Every `s.image().remote()` / `s.file().remote()` value
+ *    whose path is a remote ref gets `Remote image was not checked.` with
+ *    `image:check-remote` -- unconditionally, for every remote image in the
+ *    project.
  *
- * `val validate` resolves those by running the fix handler and then
- * `createFixPatch` in report mode, which compares each field against the file
- * and returns one error per field that disagrees. The Studio cannot do that at
- * all -- a browser has no filesystem -- so it drops them wholesale
- * (`partitionValidationErrors` in `@valbuild/shared`).
+ * `val validate` resolves both by running the fix handler and then
+ * `createFixPatch` in report mode, which returns one error per real problem
+ * and nothing at all when there is none. The Studio cannot do that -- a
+ * browser has neither the filesystem nor the project's remote credentials --
+ * so it drops them wholesale (`partitionValidationErrors` in
+ * `@valbuild/shared`).
  *
  * An editor is in the CLI's position, not the browser's, and publishing the
  * placeholders raw put a permanent warning on every image in the project. So
@@ -886,15 +944,42 @@ function traverseObjectLiteral(node, sourceFile) {
  */
 const METADATA_CHECK_FIXES = ["image:check-metadata", "file:check-metadata"];
 
-/** One field of a media value that disagrees with the file behind it. */
+/**
+ * The fixes that carry an unconditional remote-ref placeholder.
+ *
+ * The plural `images:check-remote` / `files:check-remote` are deliberately
+ * absent. `RecordSchema.validateMediaKey` emits those only for a key that is
+ * already wrong -- an unparseable remote URL, or one outside the gallery's
+ * directory -- and their messages say so. They are findings, not deferrals,
+ * and `createFixPatch` has no branch for them at all, so adjudicating one
+ * would come back empty and silently drop a real error.
+ */
+const REMOTE_CHECK_FIXES = ["image:check-remote", "file:check-remote"];
+
+/** One thing about a media value that a real check found to be wrong. */
 
 /**
- * The verdict on one placeholder. Empty means the metadata agrees with the
- * file and nothing should be published.
+ * The verdict on one placeholder. Empty means the check passed -- the metadata
+ * agrees with the file, or the remote ref is sound -- and nothing should be
+ * published.
+ */
+
+/**
+ * Whether this error is the unconditional remote-ref deferral.
+ *
+ * Unlike the metadata deferral this needs no re-derivation: `image:check-remote`
+ * is attached to exactly one error in `ImageSchema.executeValidate`, the
+ * fall-through for a remote schema with a remote path, and `FileSchema` mirrors
+ * it. Everything else a remote media field can be wrong about carries a
+ * different fix (`image:upload-remote`, `image:download-remote`) or none.
  */
+function isDeferredRemoteCheck(error) {
+  return (error.fixes ?? []).some(fix => REMOTE_CHECK_FIXES.includes(fix));
+}
 
 /**
- * Whether this error is the unconditional deferral rather than a real finding.
+ * Whether this error is the unconditional METADATA deferral rather than a real
+ * finding.
  *
  * This is the whole difficulty of the change. `image:check-metadata` is
  * attached to FIVE different image errors, and only the last is a placeholder:
@@ -913,7 +998,7 @@ const METADATA_CHECK_FIXES = ["image:check-metadata", "file:check-metadata"];
  * There is no flag on `ValidationError` saying which is which, so the four
  * conditions are re-derived here from the same inputs core used. They are
  * transcribed from `ImageSchema.executeValidate`, in its order, and
- * `mediaMetadataChecks.test.ts` drives real core through all five cases to
+ * `mediaChecks.test.ts` drives real core through all five cases to
  * check that this agrees with it. If core grows a sixth condition, that test is
  * what catches it.
  *
@@ -958,33 +1043,33 @@ function isDeferredMediaMetadataCheck({
 }
 
 /**
- * {@link isDeferredMediaMetadataCheck} for an error in a module, resolving the
- * schema it needs.
+ * Whether an error in a module is either deferral, resolving the schema the
+ * metadata classification needs.
  *
  * Both the adjudicator and `createValDiagnostics` have to make the same call,
  * on the same inputs -- one to decide what to adjudicate, the other to decide
  * what to publish -- so it lives here rather than being written out twice.
  */
-function isDeferredMediaMetadataCheckAt({
+function isDeferredMediaCheckAt({
   sourcePath,
   error,
   content
 }) {
-  return isDeferredMediaMetadataCheck({
+  return isDeferredRemoteCheck(error) || isDeferredMediaMetadataCheck({
     error,
     schema: resolveSchemaAt$1(sourcePath, content)
   });
 }
 
 /**
- * Adjudicate every deferred metadata placeholder in `validation`.
+ * Adjudicate every deferred media placeholder in `validation`.
  *
  * Async, and therefore separate from `createValDiagnostics`, which stays
  * synchronous so it can be tested without a project -- the same split
  * `resolveGalleryChecks` uses. The caller runs this first and passes the
  * result in.
  */
-async function resolveMediaMetadataChecks({
+async function resolveMediaChecks({
   validation,
   content,
   valRoot,
@@ -993,14 +1078,14 @@ async function resolveMediaMetadataChecks({
   const verdicts = new Map();
   for (const [sourcePath, errors] of Object.entries(validation)) {
     for (const error of errors) {
-      if (!isDeferredMediaMetadataCheckAt({
+      if (!isDeferredMediaCheckAt({
         sourcePath,
         error,
         content
       })) {
         continue;
       }
-      const key = mediaMetadataCheckKey(sourcePath, error);
+      const key = mediaCheckKey(sourcePath, error);
       try {
         verdicts.set(key, await adjudicate({
           sourcePath,
@@ -1012,7 +1097,7 @@ async function resolveMediaMetadataChecks({
       } catch {
         // This runs inside `validate`, which publishes NOTHING if it throws --
         // one bad image would silently clear every Val diagnostic in the file.
-        // Keep the placeholder rather than claiming the metadata is fine.
+        // Keep the placeholder rather than claiming the check passed.
         verdicts.set(key, keep(error));
       }
     }
@@ -1024,7 +1109,7 @@ async function resolveMediaMetadataChecks({
  * Key for one placeholder. A value can in principle carry more than one, so
  * the fix names are part of the key -- as they are for the gallery checks.
  */
-function mediaMetadataCheckKey(sourcePath, error) {
+function mediaCheckKey(sourcePath, error) {
   return `${sourcePath}|${(error.fixes ?? []).join(",")}`;
 }
 
@@ -1044,6 +1129,17 @@ function keep(error) {
 /**
  * What `createFixPatch` says about one placeholder, in report mode.
  *
+ * Which placeholder decides only what has to be true before asking; the asking
+ * is the same call either way, and `reportFixPatch` is it.
+ */
+async function adjudicate(args) {
+  return isDeferredRemoteCheck(args.error) ? adjudicateRemote(args) : adjudicateMetadata(args);
+}
+
+/**
+ * The metadata placeholder: does the stored width/height/mimeType match the
+ * bytes?
+ *
  * `val validate` runs the fix handler first and then `createFixPatch`, but for
  * these four fixes the handler is `handleFileMetadata`, whose whole job is the
  * precondition "the ref resolves and the file is on disk". That precondition is
@@ -1065,7 +1161,7 @@ function keep(error) {
  * `createFixPatch` reads and decodes the image itself, so this is one file read
  * per media field per validation pass, and nothing here should add another.
  */
-async function adjudicate({
+async function adjudicateMetadata({
   sourcePath,
   error,
   content,
@@ -1086,19 +1182,17 @@ async function adjudicate({
     // means this verdict never has the last word on a file that is not there.
     return keep(error);
   }
-  let fixed;
-  try {
-    fixed = await server.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, error, {}, content.source, content.schema);
-  } catch {
+  const reported = await reportFixPatch({
+    sourcePath,
+    error,
+    content,
+    valRoot,
+    remoteHost
+  });
+  if (reported === undefined) {
     return keep(error);
   }
-  return (fixed?.remainingErrors ?? []).map(remaining => ({
+  return reported.map(remaining => ({
     message: remaining.message,
     // `createFixPatch` clears `fixes` on the per-field errors it reports, but
     // the fix is still available and still the remedy -- it is what the
@@ -1114,6 +1208,77 @@ async function adjudicate({
   }));
 }
 
+/**
+ * The remote-ref placeholder: is the ref this value carries still the ref the
+ * bytes behind it produce?
+ *
+ * `handleRemoteFileCheck` is a no-op that asks for the patch, so unlike the
+ * metadata case there is no precondition of its own to stand in for -- the
+ * whole check is `checkRemoteRef` inside `createFixPatch`. It recomputes the
+ * validation hash from the schema, the file extension, the metadata on the
+ * value and the file hash in the ref; when that agrees with the ref, nothing is
+ * downloaded and nothing is reported. Only a ref that no longer adds up costs a
+ * download, and that is cached under `.val/remote-file-cache`.
+ *
+ * The findings deliberately carry no `fixes`. `createFixPatch` clears them
+ * (`Remote ref: ... is not valid. Use the --fix flag to fix this issue.`
+ * arrives with `fixes: undefined`), no quick fix is registered for
+ * `image:check-remote` -- rewriting the ref needs the bytes off the content
+ * host, so it is `val validate --fix`'s job, not a lightbulb's -- and dropping
+ * them is what makes this an Error rather than a Warning, matching the `✘` the
+ * CLI prints for the same finding.
+ */
+async function adjudicateRemote({
+  sourcePath,
+  error,
+  content,
+  valRoot,
+  remoteHost
+}) {
+  const reported = await reportFixPatch({
+    sourcePath,
+    error,
+    content,
+    valRoot,
+    remoteHost
+  });
+  if (reported === undefined) {
+    return keep(error);
+  }
+  return reported.map(remaining => ({
+    message: remaining.message,
+    ...(error.value !== undefined ? {
+      value: error.value
+    } : {})
+  }));
+}
+
+/**
+ * `createFixPatch` in report mode, or `undefined` if it could not answer.
+ *
+ * `false` is the load-bearing argument: this is a question, not a fix. Asking
+ * for the patch would have `createFixPatch` read and rewrite files behind the
+ * editor's back -- and, for a remote ref, re-derive one from bytes it had to
+ * download first.
+ */
+async function reportFixPatch({
+  sourcePath,
+  error,
+  content,
+  valRoot,
+  remoteHost
+}) {
+  try {
+    const fixed = await server.createFixPatch({
+      projectRoot: valRoot,
+      remoteHost
+    }, false, sourcePath, error, {}, content.source, content.schema);
+    return fixed?.remainingErrors ?? [];
+  } catch {
+    return undefined;
+  }
+}
+
 /**
  * The `accept` a media schema declares, if any.
  *
@@ -1238,8 +1403,18 @@ const FALLBACK_RANGE = {
   }
 };
 
-/** Fixes that operate on a file or image reference. */
-const FILE_FIXES = ["image:add-metadata", "image:check-metadata", "image:upload-remote", "image:download-remote", "image:check-remote", "file:add-metadata", "file:check-metadata", "file:upload-remote", "file:download-remote", "file:check-remote"];
+/**
+ * Fixes that operate on a LOCAL file or image reference.
+ *
+ * `*:check-remote` is deliberately absent. A remote value's bytes are on the
+ * content host by design, so "is it on disk" is never its question -- and for
+ * a path that is neither under `/public` nor a parseable remote ref, this
+ * check answered "File <root>/... does not exist" and pre-empted the remote
+ * adjudication, which has the real answer ("Invalid remote ref: ..."). The
+ * upload/download fixes stay: `*:upload-remote` is reported on a local path
+ * and a missing file really is its problem.
+ */
+const FILE_FIXES = ["image:add-metadata", "image:check-metadata", "image:upload-remote", "image:download-remote", "file:add-metadata", "file:check-metadata", "file:upload-remote", "file:download-remote"];
 function build(range, message, data) {
   return {
     range,
@@ -1257,7 +1432,7 @@ function createValDiagnostics({
   valRoot,
   snapshot,
   galleryChecks,
-  mediaMetadataChecks
+  mediaChecks
 }) {
   if (content.errors === false) {
     return [];
@@ -1329,18 +1504,20 @@ function createValDiagnostics({
         continue;
       }
 
-      // An unconditional media metadata placeholder: core reports
-      // `image:check-metadata` on every `s.image()` carrying metadata, whether
-      // or not it disagrees with the file. Show only what the adjudication
-      // actually found, and nothing when it found nothing. Deliberately after
-      // the missing-file branch above, so a deleted file is still reported as
-      // `val/file-not-found` rather than as a metadata mismatch.
-      if (isDeferredMediaMetadataCheckAt({
+      // An unconditional media placeholder: core reports
+      // `image:check-metadata` on every `s.image()` carrying metadata whether
+      // or not it disagrees with the file, and `Remote image was not checked.`
+      // on every remote image whether or not its ref is stale. Show only what
+      // the adjudication actually found, and nothing when it found nothing.
+      // Deliberately after the missing-file branch above, so a deleted file is
+      // still reported as `val/file-not-found` rather than as a metadata
+      // mismatch.
+      if (isDeferredMediaCheckAt({
         sourcePath,
         error,
         content
       })) {
-        const verdict = mediaMetadataChecks?.get(mediaMetadataCheckKey(sourcePath, error));
+        const verdict = mediaChecks?.get(mediaCheckKey(sourcePath, error));
         for (const finding of verdict ?? []) {
           diagnostics.push(build(rangeOf(sourcePath, modulePathMap), finding.message, {
             code: "val/validation",
@@ -4069,9 +4246,11 @@ function createValLanguageServer(connection) {
         })
       }) : undefined;
       // Core also defers "does this image's stored metadata match its file",
-      // reporting it on every `s.image()` that carries any metadata. Same
-      // treatment: adjudicate with the fix machinery before showing anything.
-      const mediaMetadataChecks = result.content.errors !== false && result.content.errors.validation ? await resolveMediaMetadataChecks({
+      // reporting it on every `s.image()` that carries any metadata, and
+      // "is this remote ref still valid", reporting it on every remote image.
+      // Same treatment: adjudicate with the fix machinery before showing
+      // anything.
+      const mediaChecks = result.content.errors !== false && result.content.errors.validation ? await resolveMediaChecks({
         validation: result.content.errors.validation,
         content: result.content,
         valRoot: activeProject.valRoot
@@ -4087,8 +4266,8 @@ function createValLanguageServer(connection) {
         ...(galleryChecks ? {
           galleryChecks
         } : {}),
-        ...(mediaMetadataChecks ? {
-          mediaMetadataChecks
+        ...(mediaChecks ? {
+          mediaChecks
         } : {})
       });
       const unregistered = findMissingModuleDiagnostic(project.valRoot, moduleFilePath, readOpenDocument);