final AtomicBoolean hasError = new AtomicBoolean(false);

        Thread[] threads = new Thread[threadCount];

        for (int i = 0; i < threadCount; i++) {
            threads[i] = new Thread(() -> {
                try {
                    curtainFinallyHook.hook(assistantDirector);
                } catch (Exception e) {
                    hasError.set(true);
                }
            });

     * @return true if the operation was successful, false otherwise.
     */
    public boolean deleteAllWords() {
        final SuggestDeleteResponse response = suggester.indexer().deleteAll();
        if (response.hasError()) {
            logger.warn("Failed to delete all words.", response.getErrors().get(0));
            return false;
        }
        refresh();
        return true;
    }

    /**

    private static class MockBadWordSettings {
        public void deleteAll() {
            // Mock implementation
        }
    }

    private static class MockSuggestDeleteResponse {
        public boolean hasError() {
            return false;
        }

        public List<Throwable> getErrors() {
            return new ArrayList<>();
        }
    }

  val onException: (IOException) -> Unit,
) : ForwardingSink(delegate) {
  private var hasErrors = false

  override fun write(
    source: Buffer,
    byteCount: Long,
  ) {
    if (hasErrors) {
      source.skip(byteCount)
      return
    }
    try {
      super.write(source, byteCount)
    } catch (e: IOException) {
      hasErrors = true
      onException(e)
    }
  }

  override fun flush() {