Round 2: Cross

Cross two creatures. Type two words, or pick two creatures you hatched, and they lay an egg: it cracks, and out comes
their child, with one parent's ears, the other's tail, a blend of their colors, and now and then a mutation. Someone
who crosses their name with a friend's should want to send them the child.

You start from round 1's winner. Everything it does keeps working (round 1's checks run again), and every word keeps
its creature: the checks compare 466 genomes recorded from round 1's winner. You may add fields to a genome, never
change one.

This brief is the specification of what the round adds. `ARCHITECTURE.md` and `src/rules.mjs` describe round 1 and
could not change before this round: add a "Lineages" section to `ARCHITECTURE.md` with the rules below, and their
numbers to `src/rules.mjs` as new exports (round 1's numbers stay as they are). The checks hold their own copy of
every number.

**Lineages.** A child's seed is its lineage, so a link carries the whole family tree and nothing is stored anywhere.

```
lineage = word | cross
cross   = parent "*" parent [ "#" clutch ]
parent  = word | "(" cross ")"
```

- A word is a round 1 seed, read the way round 1 reads it. A word may cross with itself.
- `×` reads as `*`, and spaces around `*`, `#`, `(` and `)` do not count: `Thomas × Auri` is `thomas*auri`.
- `#n` is a couple's n-th egg, n from 1 to 99 with no leading zero. `#1` is the first egg, written with no number.
- Parentheses wrap a parent that is itself a child, and nothing else: `(a)`, `(a)*b`, `(a*b)` on its own and
  `((a*b))*c` are refused, and so is `a*b*c` (write `(a*b)*c`).
- Every lineage has one written form: the two parents of every cross in JavaScript's default sort order
  (`[x, y].sort()`, each parent as it is written, a child with its parentheses), inner crosses first, and `#1` left
  out. `thomas*auri`, `Auri × Thomas` and `thomas*auri#1` are all `auri*thomas`; `noe*(thomas*auri)` is
  `(auri*thomas)*noe`.
- At most 6 generations (a child of two words is one generation, its child with a word two) and 120 characters,
  counted on the written form.

**The child's genome.** `genomeOf(lineage)` in `src/genome.mjs` returns it: round 1's fields inside round 1's ranges,
with:

- `seed`: the lineage's written form;
- `parents`: its two parents' lineages, each in its written form without parentheses, in the order the seed writes
  them (`(auri*thomas)*noe` has `["auri*thomas", "noe"]`);
- `clutch`: the egg's number, 1 to 99;
- `mutations`: the paths of the traits that mutated, inside `traits` and joined with dots (`"ears"`,
  `"voice.pitch"`), each once, or `[]`.

**Crossing**, `src/cross.mjs`: `cross(a, b, clutch = 1)` takes two genomes as `genomeOf` returns them (a genome with
`parents` is a child) and returns their child, exactly `genomeOf` of their lineage. It is pure: it never changes its
arguments, and neither it nor what it imports calls `Math.random` or reads the clock. It is symmetric: `cross(a, b, n)`
and `cross(b, a, n)` give the same child, in every process. A child inherits this way:

- its species is one parent's species, and its affinity one parent's affinity;
- each of its traits comes from a parent, or is a mutation listed in `mutations`. A number lies between the two
  parents' values at the same path (one of them, or a blend); any other value is one parent's value at that path.
  The child keeps every trait of its parent of the same species;
- each trait mutates 1 time in 50 (the checks accept 1 in 80 to 1 in 30 over 10,000 children), drawn afresh inside
  the ranges that keep its species appealing;
- a child of two common parents is rare 1 time in 64 (the checks accept 1 in 100 to 1 in 40); with a rare parent, the
  odds are yours;
- it takes after both parents. The checks ask that 70 % of children take a trait from each parent (where the parents
  differ in 4 traits or more), that 80 % have colors nearer their parents' than another couple's, and that 95 % of a
  couple's first four eggs differ in their traits.

The name (it should sound like both parents'), the stats, how numbers and colors blend, and what a mutation looks
like are yours.

**The command.** `node bin/hatch.mjs 'thomas*auri' '(thomas*auri)*noe#2'` prints each child like any genome, one
line of JSON each, in order. A bad lineage exits 2, with a reason on stderr and nothing on stdout.

**The page.**

- `?seed=<lineage>` (any way of writing it, URL-encoded) opens that child, and `window.__wild.creature` is exactly the
  genome the command prints.
- Typing a lineage in `seed-input` and pressing Enter hatches the child. The address then carries its lineage, `#`
  written `%23`, so that opening the link again hatches the same child. A bad lineage shows a reason in `seed-error`
  and keeps the creature on screen.
- For a child, the card (`creature-card`) shows its name, species, affinity and stats and the words of its lineage,
  and an element with test id `family-tree` shows the child and its ancestors back to its grandparents, each by its
  creature's name, with where each trait came from: which parent, or a mutation.
- Save GIF and Save card work for children, with the lineage on the card.
- How players cross is yours: two fields, picking two creatures hatched on this device, dragging one onto the other.
  Make it an event: the parents meet, an egg is laid, the child hatches.

The repository's own tests (`npm test`) expect `a*b` to be refused: update them. Everything else in round 1's brief
holds: nothing borrowed from another game, the low-res pixel 3D look, creatures made in code, nothing loaded from
outside, `dist/` under any path, and checks run offline in a headless Chromium without a GPU, through WebGL 2.

**From round 1's judging.** The judges noted four things to fix in the base. They count under the criteria they
touch:

- the page reaches `ready` 5 to 6 seconds after it opens in the checks' Chromium, against about 2 for the other
  entries: the brief asked for a smile within two seconds;
- a click or a tap among the drift's tentacles gets no reaction: every part of a creature should answer a tap;
- it runs at 30 frames per second on a desktop and 22 on a phone without a GPU, about half the other entries: keep it
  smooth;
- Save card prints the seed in capitals (`OLEG`): print it as it is written, which matters more now that seeds are
  lineages.

## How to run it

`npm ci`, then `npm run dev` and open the address it prints.

- Joy of crossing: cross your name with a friend's, lay their second and third eggs, then cross the child with a third
  word. Watch each hatch and listen to it.
- Family resemblance: for five couples, open the two parents and the child side by side and say what came from whom,
  then check it against the family tree.
- Sharing: open a grandchild's link in a private window, then save its GIF and its card and open both outside the
  browser.
- Code quality: read `src/cross.mjs` and the lineage reader, then how the page draws the family tree.