anchor.diff:    }
   }
   
  -enum _WorkSimplicationResult {
  -  cannotSimplify,
  -  lookFurther,
  -  deletePreviousAndContinue,
  -  deletePreviousAndMergedWith,
  -  mergedInto,
  -}
  -
   abstract class _IndexedDbWorkItem extends LinkedListEntry<_IndexedDbWorkItem> {
     final Completer<void> completer = Completer.sync();
   
  -  _WorkSimplicationResult mergeWith(_IndexedDbWorkItem other) =>
  -      _WorkSimplicationResult.cannotSimplify;
  +  /// Insert this item into the [pending] list, returning whether the item was
  +  /// actually added.
  +  ///
  +  /// Some items may want to look at the current state of the work queue for
  +  /// optimization purposes. For instance:
  +  ///
  +  ///  - if two writes to the same file are scheduled, they can be merged into
  +  ///    a single transaction for efficiency.
  +  ///  - if a file creation or writes are followed by inserting a delete request
  +  ///    to the same file, previous items can be deleted from the queue.
  +  bool insertInto(LinkedList<_IndexedDbWorkItem> pending) {
  +    pending.add(this);
  +    return true;
  +  }
   
     FutureOr<void> run();
   }
  
positive.code:   _WriteFileWorkItem(this.fileSystem, this.path, this.originalContent);
  
    @override
    _WorkSimplicationResult mergeWith(_IndexedDbWorkItem other) {
      if (other is _WriteFileWorkItem) {
        if (other.path == path) {
          other.writes.addAll(writes);
          return _WorkSimplicationResult.mergedInto;
        } else {
          return _WorkSimplicationResult.lookFurther;
        }
      } else if (other is _CreateFileWorkItem) {
        return other.path == path
            ? _WorkSimplicationResult.cannotSimplify
            : _WorkSimplicationResult.lookFurther;
      }
  
      return _WorkSimplicationResult.cannotSimplify;
    }
  
    @override
  
negative.code:     _checkClosed();
  
      // See if this unit of work can be combined with scheduled work units.
      if (work.insertInto(_pendingWork)) {
        _startWorkingIfNeeded();
        return work.completer.future;
      } else {
        // This item determined that it doesn't need to do any work at its place
        // in the queue, so just skip it.
        return Future.value();
      }
    }
  
    Future<void> _submitWorkFunction(
  