@@ -262,6 +262,16 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
   (`Character.isWhitespace()`) like spoken terms, checks target terms set
   through `replaceAll()` or `Map.Entry.setValue()`, and names an invalid
   character in hexadecimal (`U+001F`).
+- `importTranslationMemoryFromFilepath()` and
+  `exportTranslationMemoryToFilepath()` now throw `DeepLException`, with the
+  original exception as cause, for local I/O failures such as an unreadable
+  input file or a failed write, instead of a raw `IOException`.
+- `exportTranslationMemoryToFilepath()` with a `File` now checks that the output
+  path is free and its directory exists before creating the export job, and
+  throws `DeepLException` otherwise.
+- `waitUntilTranslationMemoryJobDone()` with a timeout, and the import and
+  export helpers that use it, now cut the last poll wait short at the timeout
+  instead of overrunning it by up to 5 seconds.
 - Translation memory and translation memory job IDs are now URL-encoded in
   request paths.
 - The style rule and custom instruction methods now URL-encode the style rule
 
@@ -1326,8 +1326,12 @@ class Example {  // Continuing class Example from above
 ```
 
 The optional timeout is the maximum time to wait for the import to finish; omit
-it to wait indefinitely. The job status is polled every 5 seconds, so the
-timeout is not accurate to the millisecond.
+it to wait indefinitely. The job status is polled every 5 seconds, and the last
+wait is cut short at the timeout.
+
+A missing input file throws `IllegalArgumentException` before any request is
+sent. Any other local I/O failure, such as an unreadable file, throws
+`DeepLException` with the I/O error as its cause.
 
 `ImportTranslationMemoryOptions` groups the import options: `setDisplayName()`,
 `setContentType()` (declared when the job is created and sent with the upload;
@@ -1409,8 +1413,11 @@ class Example {  // Continuing class Example from above
 }
 ```
 
-As with import, the timeout is optional; omit it to wait indefinitely. Instead of
-a `File`, you can pass an `OutputStream`, which is not closed:
+As with import, the timeout is optional; omit it to wait indefinitely. The output
+path is checked before the export job is created: if a file already exists there
+or its directory does not exist, `DeepLException` is thrown. A failure while
+writing the file also throws `DeepLException`, with the I/O error as its cause.
+Instead of a `File`, you can pass an `OutputStream`, which is not closed:
 
 ```java
 class Example {  // Continuing class Example from above
 
@@ -2458,8 +2458,7 @@ public TranslationMemoryJob waitUntilTranslationMemoryJobDone(String jobId)
    *
    * @param jobId ID of the job to wait for.
    * @param timeout Maximum time to wait before throwing, or <code>null</code> to wait indefinitely.
-   *     Note that this is not accurate to the millisecond, as the job status is only polled every 5
-   *     seconds.
+   *     The job status is polled every 5 seconds; the last wait is cut short at the timeout.
    * @return {@link TranslationMemoryJob} object with the status of the finished job.
    * @throws InterruptedException If the thread is interrupted during execution of this function.
    * @throws DeepLException If the timeout is exceeded, the job failed or expired, or any error
@@ -2468,20 +2467,34 @@ public TranslationMemoryJob waitUntilTranslationMemoryJobDone(String jobId)
    */
   public TranslationMemoryJob waitUntilTranslationMemoryJobDone(
       String jobId, @Nullable Duration timeout) throws DeepLException, InterruptedException {
-    long startTimeMillis = System.currentTimeMillis();
+    Long timeoutNanos = null;
+    if (timeout != null) {
+      try {
+        timeoutNanos = timeout.toNanos();
+      } catch (ArithmeticException exception) {
+        // Longer than about 292 years: treated as no limit.
+      }
+    }
+    long deadline = timeoutNanos != null ? System.nanoTime() + timeoutNanos : 0;
     TranslationMemoryJob job = getTranslationMemoryJob(jobId);
     while (!job.done()) {
       // The API always returns exactly one result; an empty list would never reach a terminal
       // status and the no-timeout overload would poll forever.
       if (job.getResults().isEmpty()) {
         throw new DeepLException("Translation memory job " + jobId + " returned no results");
       }
-      if (timeout != null && System.currentTimeMillis() - startTimeMillis > timeout.toMillis()) {
-        throw new DeepLException(
-            String.format(
-                "Manual timeout of %ds exceeded for translation memory job", timeout.getSeconds()));
+      long sleepMillis = TRANSLATION_MEMORY_JOB_POLL_INTERVAL_MILLIS;
+      if (timeoutNanos != null) {
+        long remainingMillis = (deadline - System.nanoTime()) / 1_000_000;
+        if (remainingMillis <= 0) {
+          throw new DeepLException(
+              String.format(
+                  "Manual timeout of %ds exceeded for translation memory job",
+                  timeout.getSeconds()));
+        }
+        sleepMillis = Math.min(sleepMillis, remainingMillis);
       }
-      Thread.sleep(TRANSLATION_MEMORY_JOB_POLL_INTERVAL_MILLIS);
+      Thread.sleep(sleepMillis);
       job = getTranslationMemoryJob(jobId);
     }
     if (!job.ok()) {
@@ -2592,10 +2605,12 @@ public void downloadTranslationMemoryExport(TranslationMemoryJob job, OutputStre
    *     name.
    * @return {@link TranslationMemoryJob} object for the completed import; its result carries the ID
    *     of the new translation memory.
-   * @throws IOException If the input file cannot be read.
+   * @throws IllegalArgumentException If the input file does not exist.
+   * @throws IOException Not thrown; local I/O failures are reported as {@link DeepLException}.
+   *     Declared for source compatibility.
    * @throws InterruptedException If the thread is interrupted during execution of this function.
-   * @throws DeepLException If the import fails, or any error occurs while communicating with the
-   *     DeepL API.
+   * @throws DeepLException If the input file cannot be read (with the I/O error as cause), the
+   *     import fails, or any error occurs while communicating with the DeepL API.
    */
   public TranslationMemoryJob importTranslationMemoryFromFilepath(
       File inputFile, @Nullable String displayName)
@@ -2611,23 +2626,23 @@ public TranslationMemoryJob importTranslationMemoryFromFilepath(
    * @param displayName Optional name for the resulting translation memory, defaults to the file
    *     name.
    * @param timeout Maximum time to wait for the import to finish, or <code>null</code> to wait
-   *     indefinitely. Note that this is not accurate to the millisecond, as the job status is only
-   *     polled every 5 seconds.
+   *     indefinitely. The job status is polled every 5 seconds; the last wait is cut short at the
+   *     timeout.
    * @return {@link TranslationMemoryJob} object for the completed import; its result carries the ID
    *     of the new translation memory.
-   * @throws IOException If the input file cannot be read.
+   * @throws IllegalArgumentException If the input file does not exist.
+   * @throws IOException Not thrown; local I/O failures are reported as {@link DeepLException}.
+   *     Declared for source compatibility.
    * @throws InterruptedException If the thread is interrupted during execution of this function.
-   * @throws DeepLException If the timeout is exceeded, the import fails, or any error occurs while
-   *     communicating with the DeepL API.
+   * @throws DeepLException If the input file cannot be read (with the I/O error as cause), the
+   *     timeout is exceeded, the import fails, or any error occurs while communicating with the
+   *     DeepL API.
    * @see DeepLClient#importTranslationMemoryFromFilepath(File, String)
    */
   public TranslationMemoryJob importTranslationMemoryFromFilepath(
       File inputFile, @Nullable String displayName, @Nullable Duration timeout)
       throws DeepLException, IOException, InterruptedException {
-    if (inputFile == null || !inputFile.exists()) {
-      throw new IllegalArgumentException("inputFile must be an existing file");
-    }
-    byte[] fileContent = Files.readAllBytes(inputFile.toPath());
+    byte[] fileContent = readTranslationMemoryFile(inputFile);
     TranslationMemoryImport translationMemoryImport =
         createTranslationMemoryImport(inputFile.getName(), fileContent.length, null, displayName);
     uploadTranslationMemoryFile(translationMemoryImport, fileContent);
@@ -2643,18 +2658,18 @@ public TranslationMemoryJob importTranslationMemoryFromFilepath(
    *     parameters), or <code>null</code>.
    * @return {@link TranslationMemoryJob} object for the completed import; its result carries the ID
    *     of the new translation memory.
-   * @throws IOException If the input file cannot be read.
+   * @throws IllegalArgumentException If the input file does not exist.
+   * @throws IOException Not thrown; local I/O failures are reported as {@link DeepLException}.
+   *     Declared for source compatibility.
    * @throws InterruptedException If the thread is interrupted during execution of this function.
-   * @throws DeepLException If the timeout is exceeded, the import fails, or any error occurs while
-   *     communicating with the DeepL API.
+   * @throws DeepLException If the input file cannot be read (with the I/O error as cause), the
+   *     timeout is exceeded, the import fails, or any error occurs while communicating with the
+   *     DeepL API.
    */
   public TranslationMemoryJob importTranslationMemoryFromFilepath(
       File inputFile, @Nullable ImportTranslationMemoryOptions options)
       throws DeepLException, IOException, InterruptedException {
-    if (inputFile == null || !inputFile.exists()) {
-      throw new IllegalArgumentException("inputFile must be an existing file");
-    }
-    byte[] fileContent = Files.readAllBytes(inputFile.toPath());
+    byte[] fileContent = readTranslationMemoryFile(inputFile);
     return importTranslationMemoryFromFilepath(fileContent, inputFile.getName(), options);
   }
 
@@ -2722,10 +2737,12 @@ public TranslationMemoryJob importTranslationMemoryFromFilepath(File inputFile)
    * @param translationMemoryId ID of the translation memory to export.
    * @param outputFile File to write the exported translation memory to.
    * @return {@link TranslationMemoryJob} object for the completed export.
-   * @throws IOException If the output path is occupied.
+   * @throws IOException Not thrown; local I/O failures are reported as {@link DeepLException}.
+   *     Declared for source compatibility.
    * @throws InterruptedException If the thread is interrupted during execution of this function.
-   * @throws DeepLException If the export fails, or any error occurs while communicating with the
-   *     DeepL API.
+   * @throws DeepLException If the output path is occupied or its directory does not exist (checked
+   *     before the export job is created), writing the file fails (with the I/O error as cause),
+   *     the export fails, or any error occurs while communicating with the DeepL API.
    */
   public TranslationMemoryJob exportTranslationMemoryToFilepath(
       String translationMemoryId, File outputFile)
@@ -2740,23 +2757,31 @@ public TranslationMemoryJob exportTranslationMemoryToFilepath(
    * @param translationMemoryId ID of the translation memory to export.
    * @param outputFile File to write the exported translation memory to.
    * @param timeout Maximum time to wait for the export to finish, or <code>null</code> to wait
-   *     indefinitely. Note that this is not accurate to the millisecond, as the job status is only
-   *     polled every 5 seconds.
+   *     indefinitely. The job status is polled every 5 seconds; the last wait is cut short at the
+   *     timeout.
    * @return {@link TranslationMemoryJob} object for the completed export.
-   * @throws IOException If the output path is occupied.
+   * @throws IOException Not thrown; local I/O failures are reported as {@link DeepLException}.
+   *     Declared for source compatibility.
    * @throws InterruptedException If the thread is interrupted during execution of this function.
-   * @throws DeepLException If the timeout is exceeded, the export fails, or any error occurs while
-   *     communicating with the DeepL API.
+   * @throws DeepLException If the output path is occupied or its directory does not exist (checked
+   *     before the export job is created), writing the file fails (with the I/O error as cause),
+   *     the timeout is exceeded, the export fails, or any error occurs while communicating with the
+   *     DeepL API.
    * @see DeepLClient#exportTranslationMemoryToFilepath(String, File)
    */
   public TranslationMemoryJob exportTranslationMemoryToFilepath(
       String translationMemoryId, File outputFile, @Nullable Duration timeout)
       throws DeepLException, IOException, InterruptedException {
+    checkExportOutputFile(outputFile);
     TranslationMemoryExport translationMemoryExport =
         createTranslationMemoryExport(translationMemoryId);
     TranslationMemoryJob job =
         waitUntilTranslationMemoryJobDone(translationMemoryExport.getJobId(), timeout);
-    downloadTranslationMemoryExport(job, outputFile);
+    try {
+      downloadTranslationMemoryExport(job, outputFile);
+    } catch (IOException exception) {
+      throw wrapLocalIOException("Failed to write translation memory export", exception);
+    }
     return job;
   }
 
@@ -2806,7 +2831,11 @@ public TranslationMemoryJob exportTranslationMemoryToFilepath(
         createTranslationMemoryExport(translationMemoryId);
     TranslationMemoryJob job =
         waitUntilTranslationMemoryJobDone(translationMemoryExport.getJobId(), timeout);
-    downloadTranslationMemoryExport(job, outputStream);
+    try {
+      downloadTranslationMemoryExport(job, outputStream);
+    } catch (IOException exception) {
+      throw wrapLocalIOException("Failed to write translation memory export", exception);
+    }
     return job;
   }
 
@@ -2890,6 +2919,53 @@ private static String translationMemoryJobId(TranslationMemoryJob job)
     return job.getJobId();
   }
 
+  /**
+   * Reads a TMX file for import; a missing file is an argument error, raised before any request.
+   */
+  private static byte[] readTranslationMemoryFile(@Nullable File inputFile)
+      throws DeepLException, InterruptedException {
+    if (inputFile == null || !inputFile.exists()) {
+      throw new IllegalArgumentException("inputFile must be an existing file");
+    }
+    try {
+      return Files.readAllBytes(inputFile.toPath());
+    } catch (IOException exception) {
+      throw wrapLocalIOException("Failed to read translation memory file", exception);
+    }
+  }
+
+  /** Checks the output file of an export so a bad path fails before the export job is created. */
+  private static void checkExportOutputFile(@Nullable File outputFile) throws DeepLException {
+    if (outputFile == null) {
+      throw new IllegalArgumentException("outputFile must not be null");
+    }
+    if (outputFile.exists()) {
+      throw new DeepLException("File already exists at output path");
+    }
+    File directory = outputFile.getAbsoluteFile().getParentFile();
+    if (directory == null || !directory.isDirectory()) {
+      throw new DeepLException("Directory of output path does not exist");
+    }
+  }
+
+  /**
+   * Wraps a local I/O failure in a {@link DeepLException}; an interrupted I/O operation is reported
+   * as {@link InterruptedException} instead, as caller cancellation is never wrapped.
+   */
+  private static DeepLException wrapLocalIOException(String message, IOException exception)
+      throws InterruptedException {
+    boolean interrupted =
+        exception instanceof java.nio.channels.ClosedByInterruptException
+            || (exception instanceof InterruptedIOException
+                && !(exception instanceof java.net.SocketTimeoutException));
+    if (interrupted) {
+      InterruptedException interruptedException = new InterruptedException(exception.getMessage());
+      interruptedException.initCause(exception);
+      throw interruptedException;
+    }
+    return new DeepLException(message + ": " + exception.getMessage(), exception);
+  }
+
   /** Extracts the ID of the given Spoken Terms collection. */
   private static String spokenTermsId(SpokenTerms spokenTerms) throws IllegalArgumentException {
     if (spokenTerms == null) {