Rebase derives the change from the target state with and without it, so the target's own lines survive; spec wording to match; the previous commit's test was failing 8b678b298fee

        // c applied to the target: the model does this by union, since c

        // commutes with everything it does not depend on. What the union

        // shows is what the re-derived change must produce.

        let mut with_c = target.clone();

        if with_c.add(old.clone()).is_err() {

            return fail(format!("the target state lacks dependencies of #{}; rebase onto a state that has them", c.short(12)));

        }

        let after = with_c.materialize();

        // The paths whose file differs between the target and the target with c.

        for p in target_snapshot.files.keys().chain(after.files.keys()) {

            match (target_snapshot.files.get(p), after.files.get(p)) {

            if target_snapshot.files.get(p).is_some_and(|f| f.is_conflicted()) || after.files.get(p).is_some_and(|f| f.is_conflicted()) {

                return fail(format!("{p} would be conflicted; resolve the target state or the conflict with #{} first", c.short(12)));

    assert!(err.contains("lacks dependencies"), "E needs C, which D's state does not have: {err}");

**Rebase.** `oxy rebase C --onto HEADS` re-expresses `C` against a different base: the state `HEADS` names is materialized with and without `C` added to it (commutation makes the union meaningful, and `HEADS` must contain `C`'s dependencies), the difference is re-derived as edits against the `HEADS` state, and the new change keeps `C`'s ChangeId with dependencies computed from what it now references (plus `HEADS` as explicit dependencies). This is the move a Git user makes with `rebase --onto`: it changes what a change is said to build on. It is refused when `HEADS` conflicts in any file `C` touches, since the re-derivation would have no single text to diff against, and when the result would be empty. Dependents of `C` are rewritten per §8.4. Because commuting changes already coexist, the common reason to rebase is to drop an accidental dependency, for instance on a change that is to be abandoned.