@valbuild/language-server 0.140.2 → 0.141.0

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

@@ -6,12 +6,12 @@ var fs = require('fs');
 var path = require('path');
 var ts = require('typescript');
 var core = require('@valbuild/core');
-var server = require('@valbuild/server');
 var vscodeLanguageserver = require('vscode-languageserver');
 var node = require('vscode-languageserver/node');
 var vscodeLanguageserverTextdocument = require('vscode-languageserver-textdocument');
 var crypto = require('crypto');
 var node_module = require('node:module');
+var server = require('@valbuild/server');
 var internal = require('@valbuild/shared/internal');
 var fp = require('@valbuild/core/fp');
 var patch = require('@valbuild/core/patch');
@@ -183,7 +183,7 @@ var packageJson = {
 		"lsp",
 		"language-server"
 	],
-	version: "0.140.2",
+	version: "0.141.0",
 	bin: {
 		"val-language-server": "./bin.js"
 	},
@@ -1414,7 +1414,11 @@ const FALLBACK_RANGE = {
  * 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"];
+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",
+// Local only: core never asks a remote video for its metadata.
+"video:add-metadata",
+// The same, for a video set's entry, whose file is its KEY.
+"videos:add-metadata"];
 function build(range, message, data) {
   return {
     range,
@@ -1493,7 +1497,8 @@ function createValDiagnostics({
       const missing = valRoot && fixes?.some(fix => FILE_FIXES.includes(fix)) ? missingFileRef({
         sourcePath,
         content,
-        valRoot
+        valRoot,
+        fixes
       }) : undefined;
       if (missing) {
         diagnostics.push(build(rangeOf(sourcePath, modulePathMap, "path"), `File ${missing} does not exist`, {
@@ -1578,7 +1583,8 @@ function createValDiagnostics({
 function missingFileRef({
   sourcePath,
   content,
-  valRoot
+  valRoot,
+  fixes
 }) {
   if (!content.source || !content.schema) {
     return undefined;
@@ -1586,7 +1592,9 @@ function missingFileRef({
   try {
     const [, modulePath] = core.Internal.splitModuleFilePathAndModulePath(sourcePath);
     const resolved = core.Internal.resolvePath(modulePath, content.source, content.schema);
-    const ref = resolved.source?.path;
+    const ref = fixes.includes("videos:add-metadata") ?
+    // A video set entry is keyed by its file; the value has no `path`.
+    core.Internal.splitModulePath(modulePath).pop() : resolved.source?.path;
     if (typeof ref !== "string") {
       return undefined;
     }
@@ -1721,7 +1729,7 @@ function longestResolvedPrefixRange(modulePath, modulePathMap) {
  * Gallery checks core emits unconditionally.
  *
  * `RecordSchema.validate` attaches these to every `s.imageset()` / `s.fileset()`
- * module whether or not anything is actually wrong (see
+ * / `s.videoset()` 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.
@@ -1730,7 +1738,7 @@ function longestResolvedPrefixRange(modulePath, modulePathMap) {
  * 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"];
+const GALLERY_CHECK_FIXES = ["images:check-unique-folder", "files:check-unique-folder", "videos:check-unique-folder", "images:check-all-files", "files:check-all-files", "videos:check-all-files"];
 function isGalleryCheckFix(fix) {
   return GALLERY_CHECK_FIXES.includes(fix);
 }
@@ -1830,7 +1838,9 @@ function dropDeferredPlaceholders(validation) {
  * A gallery-backed field pointing at something the gallery does not have.
  *
  * `ImageSchema.validate` reports this (`packages/core/src/schema/image.ts`:
- * "The gallery does not have an image at '…'") but attaches no `ValidationFix`,
+ * "The gallery does not have an image at '…'"), and `VideoSchema.validate` the
+ * same for a field picked from an `s.videoset()` ("The set does not have a
+ * video at '…'"), but neither attaches a `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.
@@ -1856,7 +1866,7 @@ function galleryMembershipAt({
     return undefined;
   }
   const schema = resolved.schema;
-  if (!schema || typeof schema !== "object" || !("type" in schema) || schema.type !== "image" && schema.type !== "file") {
+  if (!schema || typeof schema !== "object" || !("type" in schema) || schema.type !== "image" && schema.type !== "file" && schema.type !== "video") {
     return undefined;
   }
   const referencedModule = "referencedModule" in schema && typeof schema.referencedModule === "string" ? schema.referencedModule : undefined;
@@ -1923,6 +1933,100 @@ function minimalTextEdit(before, after, document) {
   };
 }
 
+/**
+ * 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]:)(\/|$)/;
+
+/**
+ * Matches the `*.val.json` files that hold `.jsonValues()` entry content. Not a
+ * Val module: nothing validates one on its own, but editing it changes what a
+ * module validates to, so the server has to notice.
+ */
+const VAL_JSON_ENTRY_RE = /\.val\.json$/;
+function isValModuleUri(uri) {
+  return VAL_MODULE_RE.test(uri);
+}
+function isValJsonEntryUri(uri) {
+  return VAL_JSON_ENTRY_RE.test(uri);
+}
+
+/**
+ * `decodeURIComponent` throws on malformed escapes (`%zz`). A client that sends
+ * 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__default["default"].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__default["default"].relative(valRoot, fsPath);
+  if (!relative || relative.startsWith("..") || path__default["default"].isAbsolute(relative)) {
+    return undefined;
+  }
+  return `/${relative.split(path__default["default"].sep).join("/")}`;
+}
+
 /**
  * `workspace/executeCommand` handlers.
  *
@@ -1959,7 +2063,10 @@ const REMOTE_FIX_COMMANDS = {
   "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
+  "file:download-remote": VAL_DOWNLOAD_REMOTE_COMMAND,
+  "video:upload-remote": VAL_UPLOAD_REMOTE_COMMAND,
+  "video:download-remote": VAL_DOWNLOAD_REMOTE_COMMAND,
+  "videos:upload-remote": VAL_UPLOAD_REMOTE_COMMAND
 };
 const REMOTE_FIX_TITLES = {
   "image:upload-remote": "Val: upload this image to Val Remote",
@@ -1967,7 +2074,10 @@ const REMOTE_FIX_TITLES = {
   "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"
+  "file:download-remote": "Val: download this file into the project",
+  "video:upload-remote": "Val: upload this video (and its poster and captions) to Val Remote",
+  "video:download-remote": "Val: download this video (and its poster and captions) into the project",
+  "videos:upload-remote": "Val: upload this video to Val Remote (and point the fields using it there)"
 };
 
 /** Arguments a remote-fix command is invoked with. */
@@ -2184,16 +2294,67 @@ function createValCommands(deps) {
     if (!edit) {
       return;
     }
+    const changes = {
+      [args.uri]: [edit]
+    };
+    // A fix that renames what other modules name (a video set's key) rewrites
+    // them in the same edit, so one undo takes back all of it.
+    const unwritten = [];
+    for (const other of outcome.otherModulePatches ?? []) {
+      const otherEdit = editForModulePatch(project.valRoot, other);
+      if (otherEdit) {
+        (changes[otherEdit.uri] ??= []).push(otherEdit.edit);
+      } else {
+        unwritten.push(other.moduleFilePath);
+      }
+    }
     // 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(vscodeLanguageserver.ApplyWorkspaceEditRequest.type, {
+    const applied = await connection.sendRequest(vscodeLanguageserver.ApplyWorkspaceEditRequest.type, {
       label: REMOTE_FIX_TITLES[args.fix] ?? `Val: ${args.fix}`,
       edit: {
-        changes: {
-          [args.uri]: [edit]
-        }
+        changes
       }
     });
+    // The client may refuse the edit — a document changed under it, say. The
+    // files have moved by then, but nothing names them yet, so the fix did
+    // NOT happen and must not read as though it had. Running it again is
+    // safe: refs are content-addressed, so the same bytes go to the same refs.
+    if (!applied.applied) {
+      connection.window.showErrorMessage(`Val: ${args.fix} moved the files, but the editor did not apply the change${applied.failureReason ? ` (${applied.failureReason})` : ""}. Nothing was rewritten: run the fix again.`);
+      return;
+    }
+    if (unwritten.length > 0) {
+      connection.window.showWarningMessage(`Val: ${args.fix} could not rewrite ${unwritten.join(", ")}. Run "val validate" to see what still points at the old path.`);
+    }
+  }
+
+  /**
+   * The edit for a patch to another module than the one the command ran on,
+   * against the editor's buffer when the file is open and the disk otherwise.
+   */
+  function editForModulePatch(valRoot, other) {
+    const uri = pathToUri(path__default["default"].join(valRoot, other.moduleFilePath));
+    let otherDocument = deps.getDocument(uri);
+    if (!otherDocument) {
+      let text;
+      try {
+        text = fs__default["default"].readFileSync(path__default["default"].join(valRoot, other.moduleFilePath), "utf8");
+      } catch {
+        return undefined;
+      }
+      otherDocument = vscodeLanguageserverTextdocument.TextDocument.create(uri, "typescript", 0, text);
+    }
+    const otherBefore = otherDocument.getText();
+    const otherPatched = server.patchSourceFile(otherBefore, other.patch);
+    if (fp.result.isErr(otherPatched)) {
+      return undefined;
+    }
+    const otherEdit = minimalTextEdit(otherBefore, otherPatched.value.text, otherDocument);
+    return otherEdit && {
+      uri,
+      edit: otherEdit
+    };
   }
   return {
     async execute(command, args) {
@@ -2376,100 +2537,6 @@ function valModulesEntryText({
   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]:)(\/|$)/;
-
-/**
- * Matches the `*.val.json` files that hold `.jsonValues()` entry content. Not a
- * Val module: nothing validates one on its own, but editing it changes what a
- * module validates to, so the server has to notice.
- */
-const VAL_JSON_ENTRY_RE = /\.val\.json$/;
-function isValModuleUri(uri) {
-  return VAL_MODULE_RE.test(uri);
-}
-function isValJsonEntryUri(uri) {
-  return VAL_JSON_ENTRY_RE.test(uri);
-}
-
-/**
- * `decodeURIComponent` throws on malformed escapes (`%zz`). A client that sends
- * 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__default["default"].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__default["default"].relative(valRoot, fsPath);
-  if (!relative || relative.startsWith("..") || path__default["default"].isAbsolute(relative)) {
-    return undefined;
-  }
-  return `/${relative.split(path__default["default"].sep).join("/")}`;
-}
-
 const jsonOps = new patch.JSONOps();
 
 /**
@@ -2647,9 +2714,19 @@ function supportsResourceOperation(capabilities, operation) {
  * silently required auth would just fail.
  */
 const LOCAL_FIXES = ["image:add-metadata", "image:check-metadata", "file:add-metadata", "file:check-metadata",
+// A local video's mimeType, width, height and duration, read from the file
+// (or, for an HLS stream, from its playlists) on disk.
+"video:add-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",
+// A video set's entries against its directory: entries whose file has gone
+// are dropped, and videos in the directory the set does not list are added
+// with what is read from their bytes. Filesystem only.
+"videos:check-all-files",
+// A video set entry's mimeType, width, height and duration, read from the
+// file at its KEY. The set's twin of `video:add-metadata`.
+"videos:add-metadata",
 // A view pointing at the wrong module: the schema names the right one, so the
 // fix is a value the patch already knows. Nothing read, nothing fetched.
 "view:check-module"];
@@ -2672,8 +2749,11 @@ const FIX_TITLES = {
   "image:check-metadata": "Val: update image metadata",
   "file:add-metadata": "Val: add file metadata",
   "file:check-metadata": "Val: update file metadata",
+  "video:add-metadata": "Val: add video metadata",
   "images:check-all-files": "Val: update gallery image metadata",
   "files:check-all-files": "Val: update gallery file metadata",
+  "videos:check-all-files": "Val: sync the video set with its directory",
+  "videos:add-metadata": "Val: add video metadata",
   "jsonValues:extract-entry": "Val: move entry into its own .val.json",
   "view:check-module": "Val: point this view at the module its schema names"
 };
@@ -3241,7 +3321,9 @@ function getValCompletionContext(sourceFile, offset) {
 }
 
 /** The properties Val computes from a file's bytes. */
-const MEDIA_METADATA_KEYS = ["width", "height", "mimeType"];
+const MEDIA_METADATA_KEYS = ["width", "height", "mimeType",
+// A video's: never read for an image or a file, so never written for one.
+"duration"];
 /**
  * Re-find the media object literal whose `path` value starts at
  * `pathValueStart`, and report where its metadata siblings are *now*.
@@ -3423,6 +3505,24 @@ async function resolveValCompletion({
  */
 async function readMetadata(data) {
   try {
+    if (data.mediaType === "video") {
+      // Only what could be read: a video whose duration cannot be read still
+      // gets its mime type, and `video:add-metadata` reports the rest. From
+      // the file rather than a buffer: only its headers are read.
+      const metadata = await server.extractVideoMetadataFromFile(data.filePath);
+      const rendered = {};
+      if (metadata.width !== undefined && metadata.height !== undefined) {
+        rendered.width = String(metadata.width);
+        rendered.height = String(metadata.height);
+      }
+      if (metadata.mimeType) {
+        rendered.mimeType = JSON.stringify(metadata.mimeType);
+      }
+      if (metadata.duration !== undefined) {
+        rendered.duration = String(metadata.duration);
+      }
+      return Object.keys(rendered).length > 0 ? rendered : undefined;
+    }
     const buffer = fs__default["default"].readFileSync(data.filePath);
     if (data.mediaType === "image") {
       const metadata = await server.extractImageMetadata(data.filePath, buffer);
@@ -3497,7 +3597,10 @@ function createSchemaDrivenCompletions({
       return [];
     }
     const directory = "dir" in container && typeof container.dir === "string" ? container.dir : undefined;
-    const galleryFiles = container.mediaType === "images" ? files.images(directory) : files.list(directory);
+    const galleryFiles = container.mediaType === "images" ? files.images(directory) : container.mediaType === "videos" ?
+    // A stream is keyed by its master playlist; its media playlists
+    // and segments are part of it, never keys of their own.
+    files.videos(directory) : files.list(directory);
     return items(galleryFiles.map(file => file.ref), vscodeLanguageserver.CompletionItemKind.File, range);
   }
 
@@ -3509,7 +3612,7 @@ function createSchemaDrivenCompletions({
   // 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")) {
+    if (container && typeof container === "object" && "type" in container && (container.type === "image" || container.type === "file" || container.type === "video")) {
       return mediaPathItems({
         document,
         container,
@@ -3569,7 +3672,7 @@ function mediaPathItems({
       directory = gallery.dir;
     }
   }
-  const candidates = container.type === "image" ? files.images(directory) : files.list(directory);
+  const candidates = container.type === "image" ? files.images(directory) : container.type === "video" ? files.videos(directory) : files.list(directory);
   return candidates.map((file, index) => {
     const data = {
       kind: "media-path",
@@ -3806,7 +3909,11 @@ async function createGalleryMembershipActions({
   if (register) {
     actions.push(register);
   }
-  if (allowRename && gallery.dir && onDisk) {
+
+  // A stream is a directory of files its master playlist names, and renaming
+  // the master alone would leave every one of them behind.
+  const isStream = gallery.mediaType === "video" && gallery.path.split("?")[0].toLowerCase().endsWith(".m3u8");
+  if (allowRename && gallery.dir && onDisk && !isStream) {
     const move = createMoveIntoGalleryDirectoryAction({
       document,
       gallery,
@@ -3859,7 +3966,7 @@ async function createRegisterInGalleryAction({
     },
     newText: insertion.hasProperties ? `,\n${insertion.indentation}${entry}` : `\n${insertion.indentation}${entry}\n${insertion.indentation.slice(2)}`
   };
-  return vscodeLanguageserver.CodeAction.create(`Val: add ${path__default["default"].posix.basename(gallery.path)} to the gallery`, {
+  return vscodeLanguageserver.CodeAction.create(`Val: add ${path__default["default"].posix.basename(gallery.path)} to the ${gallery.mediaType === "video" ? "video set" : "gallery"}`, {
     changes: {
       [pathToUri(galleryFile)]: [edit]
     }
@@ -3981,6 +4088,16 @@ function findRecordInsertion(sourceFile) {
  */
 async function readMetadataSource(filePath, mediaType) {
   try {
+    if (mediaType === "video") {
+      // All four or nothing: a set entry missing any of them is reported by
+      // `videos:add-metadata`, which says why it could not be read — a better
+      // place to land than a registered entry that is already wrong.
+      const metadata = await server.extractVideoMetadataFromFile(filePath);
+      if (!metadata.mimeType || metadata.width === undefined || metadata.height === undefined || metadata.duration === undefined) {
+        return undefined;
+      }
+      return `mimeType: ${JSON.stringify(metadata.mimeType)}, width: ${metadata.width}, height: ${metadata.height}, duration: ${metadata.duration}, alt: null`;
+    }
     const buffer = fs__default["default"].readFileSync(filePath);
     if (mediaType === "image") {
       const metadata = await server.extractImageMetadata(filePath, buffer);
@@ -4009,12 +4126,12 @@ function readFileOrUndefined(filePath) {
 /**
  * Lists the files a Val module may reference.
  *
- * Val stores referenced files under `/public/val` by convention (configurable
- * via `files.directory` in val.config), and a reference is written as the path
- * *including* the `/public` prefix — so this returns Val-style refs directly.
+ * Val stores referenced files under `/public/val` by convention, and a
+ * reference is written as the path *including* the `/public` prefix — so this
+ * returns Val-style refs directly.
  */
 
-/** Default directory, matching `files.directory` in val.config. */
+/** Where Val stores the files a module references. */
 const DEFAULT_FILES_DIRECTORY = "/public/val";
 
 /**
@@ -4085,6 +4202,7 @@ function createPublicValFiles({
   return {
     list,
     images: dir => list(dir).filter(f => f.mimeType?.startsWith("image/")),
+    videos: dir => list(dir).filter(f => f.mimeType?.startsWith("video/") || path__default["default"].posix.basename(f.ref) === "master.m3u8"),
     invalidate: () => {
       cache.clear();
     }
@@ -4451,24 +4569,6 @@ function createValLanguageServer(connection) {
     publicFiles = createPublicValFiles({
       valRoot: options.valRoot
     });
-    // A project can point `files.directory` somewhere other than /public/val, and
-    // media-path completions would list nothing if we assumed the default.
-    // Reading val.config is async and `initialize` is not, so the default stands
-    // until the real value arrives — completions cannot be requested before
-    // `initialize` returns anyway.
-    void server.findAndEvalValConfigFile(options.valRoot).then(config => {
-      const directory = config?.files?.directory;
-      if (directory && directory !== DEFAULT_FILES_DIRECTORY) {
-        publicFiles = createPublicValFiles({
-          valRoot: options.valRoot,
-          directory
-        });
-      }
-    }).catch(e => {
-      // A broken or unreadable val.config is reported per module by the
-      // service; here it only means "keep the default directory".
-      connection.console.warn(`Val: could not read val.config: ${e instanceof Error ? e.message : String(e)}`);
-    });
     project = createValProject({
       valRoot: options.valRoot,
       open: {