oxy merge takes a remote's bookmark 733ea16a9701

    /// §10.1): a bookmark here, or a remote's as its tracking bookmark

    /// holds it (`origin/develop`, oxygen#117), so merging what a remote

    /// has needs no switch. A working copy without changes follows.

        let here = op.view.bookmarks.get(name).copied();

        let Some(state) = here.or_else(|| remote_bookmark(&op.view, name).map(|(_, _, st)| st))

        else {

            return fail(format!(

                "no bookmark {name}, here or at a remote (oxy bookmark list --all lists them)"

            ));

        let other = self.store.get_state(&state)?.heads;

    // oxygen#117: a remote's bookmark merges without switching to it.

    let f = Repo::clone(&url, &root.join("f")).unwrap();

    assert!(!f.view().unwrap().bookmarks.contains_key("develop"));

    let merged = f.merge("origin/develop").unwrap();

    assert!(merged.changed, "{merged:?}");

    assert!(

        f.load_state_indexed(&f.bookmark_heads().unwrap())

            .unwrap()

            .contains(&d1),

        "main holds develop's change"

    );

    assert!(f

        .merge("origin/nowhere")

        .unwrap_err()

        .to_string()

        .contains("no bookmark origin/nowhere"));

A repository holds any number of bookmarks. Each workspace has a **current bookmark** (`oxy bookmark switch NAME`, recorded per workspace) that its working copy sits on and that `commit`, `log`, `push`, and `pull` act on by default. Switching refuses uncommitted work unless told what to do with it: `--discard` drops it, and `--carry` takes it along when every path it touches is the same in NAME's state as in the working copy's base (so the same edits apply there), refusing and naming the paths otherwise. `oxy bookmark create feat && oxy bookmark switch feat --carry` moves work started on one bookmark onto a new one. `oxy bookmark create NAME [CHANGE..]` names a new state (default: the current working copy's base heads); given CHANGE.., it refuses when the current state has changes recorded before the latest of them that they do not contain, since a state holds its heads' dependency closure and not everything recorded before them, unless `--upto` (the current state's changes up to CHANGE.., as Git ancestry would have it) or `--only` (exactly CHANGE.. and their dependencies) says which is meant, and `bookmark switch` reports how many changes the new state lacks of the old; `set NAME CHANGE..` moves one, `delete NAME` removes it (its changes stay until unreachable, §21), `list` shows all with their heads and the remote-tracking difference, and `oxy merge NAME` unions the named bookmark's heads into the current one (NAME is a bookmark here or a remote's tracking bookmark, `origin/develop`, as last fetched: oxygen#117), which is the whole of merging in this model: no merge change, conflicts reified (§9); a working copy without changes follows the merge, whichever state it sat on. `oxy checkout NAME` materializes a bookmark without switching to it; with uncommitted work it refuses, naming each changed path and how it changed (a *removed* path is in the working copy's base but not on disk), unless `--discard` or `--carry` (as for switching) says what to do with the work. Bookmark names, then tag names, are resolved before change prefixes wherever a change is expected (a bookmark or tag names a change when its state has one head). For builds, `oxy describe` without `-m` names the working copy as `git describe` does: its base state's tag (`v1.2`), else the nearest tag whose state the base contains with the number of changes it adds and the newest head's ChangeId (`v1.2-3-8c5ea12a`), else the bookmark and that ChangeId (`develop-8c5ea12a`), with `-dirty` when the working copy has uncommitted changes; `--json` gives the parts.

    /// Union another bookmark's heads into the current one (no merge change):

    /// a bookmark here, or a remote's (`origin/develop`) as last fetched