@@ -21,6 +21,9 @@ project format may change while we test it with students and teachers.
   stage or sprite editor. The switch at the end of the tab strip shows the
   code, both side by side, or the visual editor alone.
 - Edit images, sounds, sprite sheets, hitboxes, shaders, and Tiled maps.
+- Drag images (PNG, JPG, GIF) and sounds (WAV, OGG, MP3, AIFF, AU) from your
+  file manager onto the Files pane to copy them into the project. Existing
+  files keep their contents; matching names get a number.
 - Run programs in a separate JVM, use the console and debugger, and export a
   runnable JAR, a portable app folder, or a BlueJ/VS Code project ZIP.
 
 
@@ -8,17 +8,47 @@
 import java.nio.file.Files;
 import java.nio.file.Path;
 import java.nio.file.StandardCopyOption;
+import java.util.Locale;
 
 /**
  * "Copy built-in costume/sound into the project to edit": crops a built-in
  * image out of its Kenney atlas (pre-rotated to face right, as the library's
  * loader does) into {@code assets/images}, and copies a built-in sound file
- * into {@code assets/sounds}. The project then owns an editable file.
+ * into {@code assets/sounds}. Also imports image and sound files from the
+ * system file manager. The project then owns an editable file.
  */
 public final class AssetCopier {
 
   private AssetCopier() {}
 
+  /** Supported external assets, checked without reading the disk during a drag. */
+  public static boolean canImport(Path source) {
+    return importFolder(source) != null;
+  }
+
+  /** Copies an external asset into its project folder, keeping the original and any namesakes. */
+  public static Path copyExternalFile(Path source, Path projectRoot) throws IOException {
+    String folder = importFolder(source);
+    if (folder == null || !Files.isRegularFile(source)) {
+      throw new IOException("Choose an image or sound file: " + source.getFileName());
+    }
+    Path target = uniqueTarget(projectRoot.resolve("assets").resolve(folder),
+        source.getFileName().toString());
+    return Files.copy(source, target);
+  }
+
+  private static String importFolder(Path source) {
+    if (source == null || source.getFileName() == null) return null;
+    String name = source.getFileName().toString().toLowerCase(Locale.ROOT);
+    int dot = name.lastIndexOf('.');
+    if (dot <= 0) return null;
+    return switch (name.substring(dot + 1)) {
+      case "png", "jpg", "jpeg", "gif" -> "images";
+      case "wav", "ogg", "mp3", "aif", "aiff", "au" -> "sounds";
+      default -> null;
+    };
+  }
+
   /** Copies the built-in image into assets/images/&lt;name&gt;.png; returns the file. */
   public static Path copyBuiltinImage(BuiltinImage entry, Path projectRoot)
       throws IOException {
 
@@ -73,8 +73,68 @@ public record Result(int start, String prefix, boolean memberAccess, List<Item>
 
   private Completions() {}
 
+  /**
+   * What completion keeps between requests of one project: javac's file
+   * manager (the library jars stay open) and the other sources' texts (read
+   * again only when the file changed on disk). Used from one thread at a time.
+   */
+  public static final class Cache implements AutoCloseable {
+    private final JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
+    private StandardJavaFileManager files;
+    private List<Path> classpath;
+    private final Map<Path, Text> texts = new java.util.HashMap<>();
+
+    private record Text(java.nio.file.attribute.FileTime modified, long size, String text) {}
+
+    StandardJavaFileManager files(List<Path> classpath) throws IOException {
+      if (files == null || !classpath.equals(this.classpath)) {
+        close();
+        files = compiler.getStandardFileManager(d -> { }, null, StandardCharsets.UTF_8);
+        if (!classpath.isEmpty()) {
+          files.setLocation(StandardLocation.CLASS_PATH,
+              classpath.stream().map(Path::toFile).collect(Collectors.toList()));
+        }
+        this.classpath = List.copyOf(classpath);
+      }
+      return files;
+    }
+
+    String read(Path source) throws IOException {
+      var attributes = Files.readAttributes(source,
+          java.nio.file.attribute.BasicFileAttributes.class);
+      Text cached = texts.get(source);
+      if (cached == null || !cached.modified().equals(attributes.lastModifiedTime())
+          || cached.size() != attributes.size()) {
+        cached = new Text(attributes.lastModifiedTime(), attributes.size(),
+            Files.readString(source, StandardCharsets.UTF_8));
+        texts.put(source, cached);
+      }
+      return cached.text();
+    }
+
+    void retain(java.util.Collection<Path> sources) {
+      texts.keySet().retainAll(sources);
+    }
+
+    @Override
+    public void close() throws IOException {
+      if (files != null) {
+        files.close();
+        files = null;
+      }
+    }
+  }
+
   public static Result complete(Path file, String text, int offset, List<Path> sources,
       List<Path> classpath) throws IOException {
+    try (Cache cache = new Cache()) {
+      return complete(file, text, offset, sources, classpath, cache);
+    }
+  }
+
+  /** {@link #complete(Path, String, int, List, List)} reusing what {@code cache} keeps. */
+  public static Result complete(Path file, String text, int offset, List<Path> sources,
+      List<Path> classpath, Cache cache) throws IOException {
     int start = offset;
     while (start > 0 && Character.isJavaIdentifierPart(text.charAt(start - 1))) {
       start--;
@@ -95,24 +155,25 @@ public static Result complete(Path file, String text, int offset, List<Path> sou
     String filler = restOfLine.isBlank() ? "();" : "";
     String probe = text.substring(0, start) + PLACEHOLDER + filler + text.substring(end);
 
-    JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
+    JavaCompiler compiler = cache.compiler;
     if (compiler == null) {
       return new Result(start, prefix, memberAccess, List.of());
     }
-    try (StandardJavaFileManager files = compiler.getStandardFileManager(d -> { }, null,
-        StandardCharsets.UTF_8)) {
-      if (!classpath.isEmpty()) {
-        files.setLocation(StandardLocation.CLASS_PATH,
-            classpath.stream().map(Path::toFile).collect(Collectors.toList()));
-      }
+    { // the file manager belongs to the cache: it stays open for the next request
+      StandardJavaFileManager files = cache.files(classpath);
       Path current = file.toAbsolutePath().normalize();
       List<JavaFileObject> units = new ArrayList<>();
       for (Path source : sources) {
         Path normalized = source.toAbsolutePath().normalize();
         if (!normalized.equals(current)) {
-          units.add(new Source(normalized, Files.readString(normalized, StandardCharsets.UTF_8)));
+          try {
+            units.add(new Source(normalized, cache.read(normalized)));
+          } catch (java.nio.file.NoSuchFileException gone) {
+            // deleted since the sources were listed
+          }
         }
       }
+      cache.retain(sources.stream().map(p -> p.toAbsolutePath().normalize()).toList());
       Source edited = new Source(current, probe);
       units.add(edited);
       JavacTask task = (JavacTask) compiler.getTask(null, files, d -> { },
 
@@ -22,6 +22,7 @@
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
+import java.util.Set;
 import java.util.UUID;
 import java.util.stream.Stream;
 
@@ -49,6 +50,12 @@ public static Path rename(ScratchProject project, Path asset, String newBaseName
 
   public static Path rename(ScratchProject project, Path asset, String newBaseName,
       FileUsages.Mode mode) throws IOException {
+    return rename(project, asset, newBaseName, mode, Set.of());
+  }
+
+  /** {@link #rename(ScratchProject, Path, String, FileUsages.Mode)}, leaving the {@code skipped} usages as they are. */
+  public static Path rename(ScratchProject project, Path asset, String newBaseName,
+      FileUsages.Mode mode, Set<FileUsages.Usage> skipped) throws IOException {
     Path source = validate(project, asset);
     if (!newBaseName.matches("[A-Za-z0-9_][A-Za-z0-9_ -]*")) {
       throw new IOException("Use letters, digits, spaces, hyphens or underscores");
@@ -60,7 +67,7 @@ public static Path rename(ScratchProject project, Path asset, String newBaseName
     if (source.equals(target) || Files.exists(target)) {
       throw new IOException("Choose an unused asset name");
     }
-    return relocate(project, source, target, mode);
+    return relocate(project, source, target, mode, skipped);
   }
 
   /**
@@ -98,6 +105,12 @@ static List<FileUsages.Usage> usages(ScratchProject project, Path path) throws I
     return distinct(usages);
   }
 
+  /** Whether the user turned off the usage of this string (its path sits inside the quotes). */
+  private static boolean isSkipped(Set<FileUsages.Usage> skipped, Path file, Span span) {
+    return skipped.stream().anyMatch(u -> u.updatable() && u.file().equals(file)
+        && u.start() == span.start() + 1);
+  }
+
   private static List<FileUsages.Usage> distinct(List<FileUsages.Usage> usages) {
     Map<String, FileUsages.Usage> seen = new java.util.LinkedHashMap<>();
     for (FileUsages.Usage usage : usages) {
@@ -129,15 +142,25 @@ static Path relocate(ScratchProject project, Path source, Path target) throws IO
    */
   static Path relocate(ScratchProject project, Path source, Path target, FileUsages.Mode mode)
       throws IOException {
-    Path moved = relocateFiles(project, source, target, mode);
+    return relocate(project, source, target, mode, Set.of());
+  }
+
+  /**
+   * {@link #relocate(ScratchProject, Path, Path, FileUsages.Mode)}, leaving the
+   * {@code skipped} usages (from {@link FileUsages#find}) as they are: the user
+   * turned them off in the preview.
+   */
+  static Path relocate(ScratchProject project, Path source, Path target, FileUsages.Mode mode,
+      Set<FileUsages.Usage> skipped) throws IOException {
+    Path moved = relocateFiles(project, source, target, mode, skipped);
     // the editors' undo steps go along
     org.openpatch.scratch4j.core.io.EditorHistory.move(project.root().toRealPath(), source,
         moved);
     return moved;
   }
 
   private static Path relocateFiles(ScratchProject project, Path source, Path target,
-      FileUsages.Mode mode) throws IOException {
+      FileUsages.Mode mode, Set<FileUsages.Usage> skipped) throws IOException {
     boolean folder = Files.isDirectory(source);
     if (folder) {
       for (Path file : files(source)) {
@@ -154,7 +177,8 @@ private static Path relocateFiles(ScratchProject project, Path source, Path targ
     }
     Map<Path, String> original = new HashMap<>();
     Map<Path, List<Span>> spans = new HashMap<>();
-    Map<Span, String> replacements = new HashMap<>();
+    // per file: two files can have a path at the same offsets
+    Map<Path, Map<Span, String>> replacements = new HashMap<>();
     Map<String, String> refs = new HashMap<>();
     List<FileUsages.Usage> manual = new ArrayList<>();
     for (Path file : files(source)) {
@@ -166,9 +190,13 @@ private static Path relocateFiles(ScratchProject project, Path source, Path targ
       manual.addAll(scan.manual());
       original.putAll(scan.original());
       for (Map.Entry<Path, List<Span>> entry : scan.literals().entrySet()) {
-        spans.computeIfAbsent(entry.getKey(), key -> new ArrayList<>())
-            .addAll(entry.getValue());
-        entry.getValue().forEach(span -> replacements.put(span, "\"" + newRef + "\""));
+        List<Span> kept = entry.getValue().stream()
+            .filter(span -> !isSkipped(skipped, entry.getKey(), span))
+            .toList();
+        if (kept.isEmpty()) continue;
+        spans.computeIfAbsent(entry.getKey(), key -> new ArrayList<>()).addAll(kept);
+        kept.forEach(span -> replacements.computeIfAbsent(entry.getKey(), key -> new HashMap<>())
+            .put(span, "\"" + newRef + "\""));
       }
     }
     if (folder) {
@@ -184,11 +212,13 @@ private static Path relocateFiles(ScratchProject project, Path source, Path targ
       StringBuilder code = new StringBuilder(original.get(entry.getKey()));
       entry.getValue().stream().distinct()
           .sorted(Comparator.comparingInt(Span::start).reversed())
-          .forEach(span -> code.replace(span.start(), span.end(), replacements.get(span)));
+          .forEach(span -> code.replace(span.start(), span.end(),
+              replacements.get(entry.getKey()).get(span)));
       changes.put(entry.getKey(), code.toString());
     }
     String oldSplash = project.settings().splashLogo;
-    String newSplash = oldSplash == null ? null : refs.get(oldSplash);
+    boolean keepSplash = skipped.stream().anyMatch(u -> u.updatable() && u.line() == 0);
+    String newSplash = oldSplash == null || keepSplash ? null : refs.get(oldSplash);
     List<Path> written = new ArrayList<>();
     boolean done = false;
     try {
 
@@ -31,8 +31,14 @@ public static Path move(ScratchProject project, Path file, Path folder) throws I
   }
 
   /** {@link #move(ScratchProject, Path, Path)}, choosing what happens to the file's usages. */
-  public static Path move(ScratchProject project, Path file, Path folder, FileUsages.Mode mode)
-      throws IOException {
+  public static Path move(ScratchProject project, Path file, Path folder,
+      FileUsages.Mode mode) throws IOException {
+    return move(project, file, folder, mode, java.util.Set.of());
+  }
+
+  /** Like the method above, leaving the {@code skipped} usages (turned off in the preview). */
+  public static Path move(ScratchProject project, Path file, Path folder,
+      FileUsages.Mode mode, java.util.Set<FileUsages.Usage> skipped) throws IOException {
     Path root = project.root().toRealPath();
     Path source = movable(project, file);
     Path directory = folder.toRealPath();
@@ -55,7 +61,7 @@ public static Path move(ScratchProject project, Path file, Path folder, FileUsag
       // back to the project folder: the default package needs no other change
       return Files.move(source, target);
     }
-    return ProjectAssetManagement.relocate(project, source, target, mode);
+    return ProjectAssetManagement.relocate(project, source, target, mode, skipped);
   }
 
   /**
@@ -70,6 +76,12 @@ public static Path rename(ScratchProject project, Path file, String newName)
   /** {@link #rename(ScratchProject, Path, String)}, choosing what happens to the usages. */
   public static Path rename(ScratchProject project, Path file, String newName,
       FileUsages.Mode mode) throws IOException {
+    return rename(project, file, newName, mode, java.util.Set.of());
+  }
+
+  /** Like the method above, leaving the {@code skipped} usages (turned off in the preview). */
+  public static Path rename(ScratchProject project, Path file, String newName,
+      FileUsages.Mode mode, java.util.Set<FileUsages.Usage> skipped) throws IOException {
     Path source = movable(project, file);
     if (source.getFileName().toString().endsWith(".java")) {
       throw new IOException("Rename a Java file by renaming its class");
@@ -82,7 +94,7 @@ public static Path rename(ScratchProject project, Path file, String newName,
     if (source.equals(target) || Files.exists(target)) {
       throw new IOException("Choose an unused file name");
     }
-    return ProjectAssetManagement.relocate(project, source, target, mode);
+    return ProjectAssetManagement.relocate(project, source, target, mode, skipped);
   }
 
   /**
 
@@ -48,14 +48,20 @@ public static Path rename(ScratchProject project, Path folder, String newName)
   /** {@link #rename(ScratchProject, Path, String)}, choosing what happens to the usages. */
   public static Path rename(ScratchProject project, Path folder, String newName,
       FileUsages.Mode mode) throws IOException {
+    return rename(project, folder, newName, mode, java.util.Set.of());
+  }
+
+  /** Like the method above, leaving the {@code skipped} usages (turned off in the preview). */
+  public static Path rename(ScratchProject project, Path folder, String newName,
+      FileUsages.Mode mode, java.util.Set<FileUsages.Usage> skipped) throws IOException {
     Path source = validate(project, folder);
     checkName(newName);
     Path target = source.resolveSibling(newName);
     if (source.equals(target) || Files.exists(target)) {
       throw new IOException("Choose an unused folder name");
     }
     checkMovable(source);
-    return ProjectAssetManagement.relocate(project, source, target, mode);
+    return ProjectAssetManagement.relocate(project, source, target, mode, skipped);
   }
 
   /** Moves a folder (with everything in it) into another project folder. */
@@ -67,6 +73,12 @@ public static Path move(ScratchProject project, Path folder, Path newParent)
   /** {@link #move(ScratchProject, Path, Path)}, choosing what happens to the usages. */
   public static Path move(ScratchProject project, Path folder, Path newParent,
       FileUsages.Mode mode) throws IOException {
+    return move(project, folder, newParent, mode, java.util.Set.of());
+  }
+
+  /** Like the method above, leaving the {@code skipped} usages (turned off in the preview). */
+  public static Path move(ScratchProject project, Path folder, Path newParent,
+      FileUsages.Mode mode, java.util.Set<FileUsages.Usage> skipped) throws IOException {
     Path source = validate(project, folder);
     Path root = project.root().toRealPath();
     Path parent = newParent.toRealPath();
@@ -85,7 +97,7 @@ public static Path move(ScratchProject project, Path folder, Path newParent,
       throw new IOException("The folder already contains " + source.getFileName());
     }
     checkMovable(source);
-    return ProjectAssetManagement.relocate(project, source, target, mode);
+    return ProjectAssetManagement.relocate(project, source, target, mode, skipped);
   }
 
   /** Java classes stay in the project folder (no packages), so their folders stay too. */