chromosomix 0.15.0

What changed in chromosomix 0.15.0, released on 17 October 2026.

There is no 0.14.0. A v0.14.0 tag and a GitHub release for it were made by hand, on the commit that merged #114, before npm version had bumped package.json: that build calls itself 0.13.0, its release carries no installers, and nothing was published to npm. Everything below is 0.15.0, cut the usual way, and the first version of the package on npm.

Added

• The site describes itself to language models and crawlers (§11). chromosomix.app/llms.txt, in the shape llmstxt.org gives one: what the app is, the formats it opens, how to write a link that opens a file at a place — every hash key a model is likely to want, with a map’s region 0-based and the 1D browser’s locus as displayed — how to embed it, how to run the command line, and where the documentation is. A test holds what it says to the app: each example link through the hash’s own reader, each value it lists against its list, each task against the registry and each store against the shelf, and it names no dev feature (§29.5). Beside it, llms-full.txt is the README as one file, generated at build time with its links made absolute; robots.txt welcomes every crawler but keeps the archived pins and pull-request previews out of search; and sitemap.xml lists the app and its validation and timing notebooks. New Open Graph tags give a pasted link a card to unfurl with.

• chromosomix.app is written to be found by a search (§11). The page’s title and description now name what the app is searched by — genome browser for Hi-C, tracks and 3D models; Hi-C and Micro-C, .cool, .mcool and .hic — short enough for a results page to print whole, where the title said cool files, in the browser. And the app no longer writes its bare name over that title the moment it mounts: a search engine indexes the page as it stands after the script has run, so no title the page was given had ever reached one. On the web a tab with nothing open keeps the page’s title; with a file open it is still the file’s name and the app’s. A canonical link lists every address of the app — ?store=, ?config=, ?embed=1 — under the root; the <noscript> says what the app is, what it reads and where its source and llms.txt are, for a reader or a crawler without JavaScript, at the top of the page — it said only that JavaScript was needed, a screen’s height down a blank page, under the empty space the app mounts into; and the npm package’s description and keywords name the data and the analyses rather than metagenomics and metacool, a dev feature’s (§29.5).

• chromosomix --version (§23). The first line is chromosomix and the version, with the commit the build was made from — the words every file the command writes opens with, so head -1 is what a pipeline records. Then the Node it runs on, with the platform, and the h5wasm and @gmod/bbi installed beside it, which read every map and track: both are ranges in package.json, settled at install, so two installs of one version can read a file through two builds of either. Answered wherever on the line it is written, as --help is. It printed the usage until now.

• Every build carries the licences of what it compiles in (§22.4). THIRD-PARTY-NOTICES.txt beside the site’s, an archived pin’s, the desktop renderer’s and the package’s index.html, and beside the command in dist-cli/; a comment at the end of the standalone page, which may not be two files. It lists what the build carries — read off the bundle, workers included, so the CLI’s external h5wasm and @gmod/bbi are not listed and echarts’ zrender is — and reproduces each licence in full: echarts’ NOTICE and the d3 licence it embeds, HDF5’s inside h5wasm’s, and the material generators copied into the source from Lucide, Simple Icons, chromosight, matplotlib and ColorBrewer, whose upstream texts that are not npm packages are committed under licenses/. Every build’s check refuses one without them. Minifying had dropped every notice but three.js’s, and a tarball carried chromosomix’s own LICENSE alone. The README’s licence section says where each build keeps them.

• A guided tutorial, from the landing page and About (§30). play the tutorial, on the landing page beside Load files and in About, walks a newcomer through a first session on a real map, one step at a time, with the window lightly greyed and the one control the step is about lit: the store drawer, opened from its header button on the lab’s store, then switched to 4DN’s; the IMR-90 Hi-C set 4DNES4296C5Q (a billion contacts), its accession in colour with a copy button, blinking when something else is typed; the set opened with its tracks, the General and Aesthetics columns shown, 250 kb and chr13; the map drawn as a correlation to show its plaid; the Analysis panel’s 2D, 3D and 1D tasks shown one group at a time, then Compartments run on chr13 alone, and its saddle; back to balanced, two Shift-Option drags across the squares the tutorial lights, down to a few domains at 10 kb, seen with O/E and 3 × 3 smoothing; Diamond insulation on chr13; the domains drawn as a lane under the map; Track correlation of the reader’s E1 and insulation against 4DN’s, the four ticked in one step; and the console. Each step moves on when what it asks for is done, however it was done, and shows a tick first. The card points at what to press, glides to the next thing, says what the step asks with an icon, and carries a progress bar cut into the tutorial’s ten parts, back, skip step and skip tutorial; ← and → step through it, and a press on the grey shows where to press instead. Skipped half way, the landing page and About offer to resume at the part the reader left; finished, to play it again. Also in the palette as Guided tutorial. Nothing opens by itself.

• Tab goes on to the next field of its kind (§26.8). In any field edited in place, Tab now takes what was typed, as Enter does, and puts the caret in the next field of the same kind — Shift+Tab the one before — and past the last lets it go: a track’s name to the next track’s, down the browser’s lanes and through every stack round a map; a range’s bottom to its top and on to the next track’s bottom; a colour key’s low end to its high end, and on a deck to the next map’s key; a deck cell’s heading to the next cell’s; a row’s name on the Tracks, Metadata, Structures or Contact maps card to the next row’s; a tab’s name to the next tab’s; a mark’s last box to the next mark’s row; a sequence’s name on the editing stage to the next sequence’s; the 3D key’s bottom to its top. A value a field refuses keeps the caret, as Enter does. Tab used to jump to whatever button came next in the page — and on the editing stage it threw the typed name away. On the way, a colour key’s end opened and left as it was no longer fixes the bound at the number it showed, and its box opens on that number as the key prints it, -1.054, rather than on the float behind it, -1.0543182366, whose end was all the box had room for.

• The installed app keeps its folders, and a saved workspace finds its files in them again (§20.6). In the desktop app — or the site installed as an app — a connected folder is kept across restarts, and a workspace saved there records which folder each of its local files was in and where: reopened, it opens the map and its tracks from the folder with nobody asked for a file, and on another machine its note names the folder to connect, with a button that does. The desktop app now lets its own page re-read what the user chose, and nothing else.

• The tracks’ names beside the map, in its corners, with the name column on (§8.8). The 1D browser’s name column switch (u) is now at the end of the all tracks row of the map’s Tracks card too, and moves the names beside a map as well: on, each stack’s names stand in the corner that follows it clockwise — left of the tracks under the map, below the ones on its right, above the ones on its left, right of the ones above it — rather than over the start of each track, where a name and its range cover the first stretch of the signal. A short name sits in the margin beside the map’s own labels and a long one runs out over the corner, which grows to fit (wrapping a name past 150 px); the range sits under its name, and a press on either still opens its caret, a right click the lane’s menu. Figures saved from the map carry them where the screen does. The switch is off to begin with, so the names are written over the tracks as they always were; for a while the corners were the only place they went, with no switch on the map’s card to put them back.

• Each cell of the deck can be on a sequence of its own (§16.3). Every map’s heading now says which sequence it shows, as a quiet picker beside its name: pick V on one cell and that map leaves the chain and reads the whole of V at its own resolution while the others stay on IV — its window is remembered with the map, and the × on it puts the map back on the others’ window. On the first map the picker goes where the locus box would, and every map following it goes along.

• A scalogram’s lane reads in distances (§18.12). Its range said 0 – 16.7, the logarithms of the reach, and its floor sat at one base pair, so the lower half of the lane was a band no value could reach. It now says 1 kb – 104 kb, starts at the power of ten below its data, and carries an axis of its own: a faint dashed rule at 10 kb, 100 kb, 1 Mb… with the distance written at the lane’s far end, stepping round the names rather than through them — beside a map, in the browser and in a saved figure. Any log2 lane gets the rules and the floor; one whose values are lengths gets them in kb and Mb.

• A box over the Analysis column narrows the task list (§18.1). filter 25 tasks…: every word typed must be in a task’s title, its blurb, its card’s heading or its other names — each task now carries the words a reader looks for it by, TAD for insulation and the directionality index, pileup for APA, A/B and eigenvector for the compartments, decay for P(s). A card with nothing left goes, nothing left at all is said, Escape gives the list back and Enter opens the first task left that can run.

• Every step back, as a list, from a chevron beside the header’s back button (§5.5). It names each step behind the one on screen — the window, a block of two, the whole genome, a table — with the resolution, the O/E or the comparison it set beside it and the file where that is another one, and a row goes straight there, as that many presses of back would. The app keeps a record of the entries it writes, which the browser does not list, in the window’s own storage, so the list survives a reload.

• Two windows typed in a locus box open the block between them (§5.4, §26.1). chr1:1,000-2,000 chr2:3,000-4,000, or the same with x, | or × between, opens chr1 against chr2 — rows, then columns — in the region view’s box, the whole genome’s and the Chromosomes table’s; everything after the first window used to be dropped without a word. On a block of two windows the box shows both, IV:1,000,001-1,200,000 × V:1-200,000, where it showed the rows alone and Enter on it threw the columns away.

• A row of the Files column dropped on Load a map into the lower triangle is the second map in the square (§5.7, §20.5). The Contact maps card’s slot took only a file from the desktop: a row dragged out of a connected folder lit it and fell in for nothing. The row’s file is read at the drop, through its folder, with the credential the folder lists with and the name a Drive or a Dropbox gives it; on a session with no map it is the first map. The slot no longer lights for the card’s own grips or for text dragged across it.

• The validation and the timings are published with every release, at https://chromosomix.app/validation/ and https://chromosomix.app/timings/ (§18.10). A new workflow, .github/workflows/notebooks.yml, installs every reference on a fresh runner at the versions the notebooks were written against — notebooks/requirements.txt and requirements-yapc.txt pin them — renders both notebooks and publishes them beside the app, each with its tables beside it: every command, every verdict and every timed run. It runs when a release is published, attaching both pages, every verdict and every timed run to the release as well, and on demand, with the number of timed runs and whether to publish; every run keeps what it rendered as an artifact, even when the timings fail. Each page opens on when it was rendered, from which version, commit and release, by which run, on what machine, and closes on how long it took, and the two link to each other. The service worker leaves both addresses to the network, as it does archived builds, so a visitor who has installed the app reaches the page rather than the app — once their copy has taken this version’s update; until then, an older worker answers there with the app.

• chromosomix boost writes Boost-HiC’s map of each sequence (§6.5). The map an oversample draws a sequence’s new contacts from, which nothing showed: each sequence’s stored counts, the square an oversample hands Boost-HiC, through the same port, written as Boost-HiC’s main.py writes its own — the bins its outlier filter keeps and the boosted map over them, in SCN units, one square TSV a sequence. --sequences names some and --alpha another exponent; a sequence past 3,000 bins is refused by name, as an oversample refuses it. Over three mouse chromosomes at 100 kb it keeps the same bins as Boost-HiC’s Python and agrees with it within 5 × 10⁻¹⁰, ten times faster on chr1.

• Copy beside PNG and PDF on every task’s figure (§18.13). It puts the figure’s PNG — the same 300 dpi redraw the PNG button saves — on the clipboard, to paste into a slide or a message without a file in between, and says in the corner what was copied and at what size.

• The lab’s store opens the Chromosomix paper, five tabs, a panel each (§24.2, §24.3). The Chromosomix paper replaces Chromosomix, Fig. 1 under Papers. Fig. 1c is 4DN’s mouse ES-cell Hi-C at five scales side by side, each map at its own rung and on its own window — the genome at 2.5 Mb, chromosome 3 as the correlation of its observed/expected at 250 kb with E1 and A/B under it, chr3:27–37 Mb at 10 kb with its insulation and borders, the Sox2 locus as observed/expected at 5 kb with its genes, CTCF and loops, and Sox2 with its control region at 2 kb with H3K27ac and H3K4me3 — and under each map the model the figure inferred at that scale, coloured by a track. Fig. 1d is chr3:32–36 Mb at 10 kb with its insulation, borders, CTCF and genes, beside chromosome 3’s model coloured by CTCF. Fig. 2a is C. necator’s first chromosome, its origin in the middle, over the decay along the diagonal and then along both arms; Fig. 2b the B. subtilis wild type, ΔparAB and six times after ParB is induced; Fig. 2c P. aeruginosa WT, SMC-ScpAB– and MksBEF– as the correlation along both arms, with each strain’s E1 under its map and the wild type’s RNA-seq (PAK at T0, GEO GSE76513, drawn to 30 CPM) under its own. A deck keeps one look a map, so a panel that reads one map several ways opens on one of them and the map’s score picker has the rest. The files are one folder, demo/store/chromosomix_paper/, a subfolder an organism, the bacterial maps and the RNA-seq copied there from where the lab keeps them so the card names none of those places; scripts/make_rsg_store.py derive computes the three E1 tracks with chromosomix compartments, as the zoo does. The bucket needs scripts/publish-store.sh again.

• A model coloured by a track can run from white to the track’s colour, and its key’s ends can be typed into (§25.5). White to the track’s colour joins the colour-scale picker under a track, so a model coloured by H3K27ac is drawn in its lane’s orange. A click on either end of the key’s range puts a caret in it, as on a lane; the number is written to the lane’s limits, so the lane follows, and an arrow beside the range puts the track back on autoscale.

• Find a motif searches a genome too large to hold, and searches the sequences ticked (§8.8, §18.8). A FASTA opened by its .fai — a mouse or human genome — or a .2bit was refused by the search for not being held in memory; it is now read by range sixteen megabases at a time, each piece scanned and let go, with an overlap one base short of the motif so a site across a seam is found once, and the sites are the ones a search of the whole file finds. The form takes the sequences to search as tick boxes, all of them to begin with; fewer are named in the lane (GATC on chr1) and get rows of their own. Over a reference read by range the line beside Run prices the read — every base of the ticked sequences, in bytes, and over a network in requests — and a Stop is seen between two pieces.

• The chromosomix command opens a --sequence by its index (§23.1, §8.21). A FASTA with its .fai beside it, or a .2bit, is read by range as the browser reads it, so a mammalian reference is a reference from a shell: Node’s readFile refuses a file past 2 GiB, which was every plain mouse or human FASTA. One past it with no index is refused by a sentence naming samtools faidx.

• Marks hidden and shown, one or all of them, on every map, track and model at once (§8.1). Each row of the Manual annotations card has an eye, as a track’s row does, and the list a heading, MARKS, with how many are hidden and one eye for all of them over the rows’ eyes; A is that eye from the keyboard, and the palette’s Manual annotations switch. A hidden mark leaves the map (square or turned), the lanes and their anchors, the 1D browser, a tracks cell and the 3D model — its bead, its chord, its colouring — and figures, and stays on the card to be shown again. Hiding every mark and showing them again brings back exactly what was drawn: a mark hidden from its own row stays hidden. A double-click on an eye shows that mark alone, and a second brings the rest back. Every right-click menu — the map’s, a lane’s, the 1D browser’s and the model’s — names the marks under the pointer, Hide this line and the like, measured on the ink as it is drawn, and offers Hide every mark or Show the marks. Hidden marks are kept with the session, a link and a reopen at another resolution, and the card’s BED and BEDPE still carry them.

• Inter-arm alignment draws what its detrending leaves, and the two decays it divides by (§18.8). The profile after detrend — the same cells over the decay along both arms — is a curve beside the measurement’s, the two opening on one ordinate so a flat control reads as flat; and a log–log figure gives the two expectations, the ordinary decay along the diagonal and the decay along both arms within an arm and across them from the secondary diagonal, log-binned as P(s)’s expected curve is (task version 7).

• A table’s names can be a scatter’s abscissa, and the scatter its least-squares line (§18.13). A text column whose cells write numbers — the all-maps table’s Map, where the maps are +parB 15 min, +parB 30 min — is offered as the abscissa, each row at the first number in its name and a name with none left out; least squares draws the fitted line, named in the legend by its equation, r² and n, so the slope of a time course goes out in its PNG and PDF. The line is fitted to the points in the abscissa’s window and refitted as it moves, so a box drawn across the points that are under way fits those alone.

• Half a window upstream and downstream, beside go on a region (§5.4). Two arrows straight after the locus box’s go move the window half its own width along the sequence, re-read as a navigation, so a reader at a locus can walk the chromosome without retyping it. They slide in to stop at an end and grey once there, on the whole sequence and on a block of two sequences, and name the window they would open in their tooltips.

• Back and forward in the header (§5.5). The browser’s own back and forward as two buttons, past a divider after the four panels’ toggles, greyed where the browser says there is nowhere to go.

• A model’s PDF is lit, as its PNG is (§25.7). Every bead is a shaded sphere, a PDF radial shading from a highlight to a shadowed rim, and the tube and the sticks are drawn band by band from the rim in shadow to a highlight on the side the screen’s key light comes from, so the fibre reads as a solid on paper rather than as flat ribbons. Still paths and shadings and nothing else, smooth at any zoom; the fog fades the shading with the rest. The file is larger for it.

• Every colour swatch opens one picker of the app’s own, hex first, with the colours last picked (§26.6). The six digits are the box, ready to type or paste into; the square and the hue bar can be dragged across without the picker closing — the platform’s closed after the first step, because the card under it was rebuilt — and the lane follows the drag. Under them, the last sixteen colours picked anywhere in the app, one click each; an eyedropper where the browser has one.

• A bar under the 1D browser’s tracks makes them all taller or shorter together, each in proportion (§5.8). The deck cell’s height bar in look, under the last track: dragged, every track’s height is scaled by one factor, so their sizes relative to each other stay as they were; Escape mid-drag puts them back, a double click fits the whole stack to the window, and the arrow keys step it. Only in the 1D browser on its own — not beside a map, nor in a deck. The canvas now gives its height back when the tracks are made shorter, and Stretch the tracks (h) fills the window rather than a canvas a tall stack had grown.

• The map says how to zoom into a region while the pointer is over it (§8.9). Under the key in its top-right corner — or in the corner itself with the legend off — a line or two of plain text: Alt + drag to zoom into a region and Shift + Alt + drag to zoom along the diagonal, or ⌥ and ⇧ on a Mac. One line under the diagonal lock, which already pins the box, a stretch on a turned map, and no Shift line on a block the diagonal does not cross. Gone when the pointer leaves, never in an export, and not on a touch screen. The 1D browser says Alt + drag to zoom into a stretch, or drag along the ruler under its ruler.

• Base modifications from a BAM’s MM/ML tags (§8.13, §8.20). A pile lane’s colour by offers base modification: the reads are drawn grey and each 5mC, 5hmC, 6mA or other call sits at its own base, red where modified and blue where not, as opaque as the caller was sure — for the code chosen from the ones the file’s reads carry, at a probability threshold the reader sets. A hover on a call names its code, probability and base, and a read’s card counts its calls. The depth row can draw the percentage modified instead, base by base, from the same reads under the same filters: a bedMethyl made in the browser. Reverse-strand reads are counted on their sequence as read, . and ? modes are told apart, two codes on one base, ChEBI codes and the N wildcard are read, and calls in soft clips and insertions are dropped. A simulated nanopore BAM over yeast chrIV is in demo/yeast/ to try it on.

• Every called set is drawn on the map and as a lane (§18.7, §8.1, §8.16). Peaks, insulation’s boundaries and domains, the DI’s borders and domains, A/B compartments, Pattern detection’s borders, origins, sites, flagged contigs and MAGs used to arrive as an overlay on the map only — beside a map a peak set could not be read against the coverage it was called on. Each now arrives as two rows of the Tracks card, linked: the overlay, and a lane of segments placed directly under the row it is read against — the peaks under their bigWig, the A/B segments under E1, the boundaries under the insulation track. Each row’s settings and the drawer carry on the map and as a lane, which are the two rows’ eyes and are remembered as they are (§8.6). A loop set’s lane is its anchors, and starts off; with no map — the 1D browser — the lane comes alone. Segments carry a name — A/B, peak_12, domain_3, boundary_40 — into the BED, and a lane can be coloured by its name column, which a compartment lane is from the start.

• The stage’s corner dot plot zooms, grows, and answers the map — a dev feature (§27.3). The wheel zooms it about the pointer, a drag moves it and a double click shows it whole, as the dot plot’s own view does, the lines sharp at any zoom; a grip at its lower-left corner sizes it, kept on the map and remembered with the file. Hovering a contig’s name on a pieces bar, or its row on the sequences card, lights its lines in the plot and dims the rest; hovering a line in the plot lights its contig on the map — dashed on the diagonal, bracketed on both bars, its name in the accent.

• A FASTA’s six reading frames, in any of NCBI’s genetic codes (§8.8). Reading frames in a sequence row’s settings draws six rows under its residues — +1, +2, +3 over −1, −2, −3, anchored to the sequence’s first base so they do not move with the window — each codon a shaded box with its amino acid in it, starts green and stops red; further out the starts and stops alone as ticks, to 24 bases a pixel. The code beside it offers every NCBI translation table, so a Mycoplasma’s frames can be read in table 4, where TGA is tryptophan and not a stop. A hover over a row names the codon and what it codes for; both settings are remembered with the row.

• A 3D model coloured by a BED’s names, A red and B blue (§25.5, §8.16). Every feature set with a name column — a BED4 or wider, a bigBed, a task’s segments — is offered under the model’s colour by as · names: each bead takes the name that overlaps it most, so a compartment call colours the model A and B, and a bead under no feature stays grey. The key lists each name with a swatch that is a colour picker; the colour is kept on the set’s row with the session, so it is that name’s colour on every model coloured by the set and on the set’s own lane, which can now be coloured by name too. Exactly A and B start red and blue, anything else on the categorical palette by base pairs covered; past twenty-three names the rest are one other the key counts.

• Every map drawn to one number of contacts (§6.5). A box labelled contacts ends the breadcrumb, showing the map’s own total in grey — the sum of cooler info, 179,175,551 for the yeast micro-C. A total typed into it — 10M, 23,000,000, 2.5e7 — draws every map of the tab to that many contacts, the whole file, not the window on screen: subsampled where a map holds more, exactly as cooltools random-sample --count N --exact does (a uniform subset of N contacts, drawn a sequence at a time from a census of the map rather than held whole), and oversampled where it holds fewer, through a port of Boost-HiC (Carron et al. 2019): every stored contact kept, and N − T more drawn from the boosted map within each sequence and from the file’s own pixels between them. Every picture, pooled read and task reads the drawn map, balanced values stay on the file’s scale, and the total is in the link (contacts=) and survives a navigation. A task’s framing and its console command say it (--contacts N, which chromosomix takes with the same parser and the same seed), and so does an exported figure’s caption: subsampled to 10,000,000 contacts (of 179,175,551). With two maps or more on screen — a deck, or a second file under the diagonal — two chevrons follow the box: down draws every map to the shallowest one’s total, up to the deepest one’s. A .hic’s total is counted rather than taken from its header, which counts each contact off a chromosome’s diagonal twice. Refused by name: a total that is not a whole number, counts that are not contacts, a square file, an .scool, and an oversample of a sequence past 3,000 bins — Boost-HiC’s Floyd–Warshall, run here as a WebAssembly SIMD kernel, is cubic in them — with read as stored offered where the map was.

  The count stays out of the way of what is being looked at: it reads nothing until what a view asked for has been answered, and between pairs it waits until no view has read for a quarter of a second, as the first open’s circularity check does; each pair’s record is read only as far as the coarsest rung and each block as exactly its bytes. On a 5 GB .hic it costs under 1 MB and the Chromosomes table is up in 5 s; a chromosome clicked while a 1 GB .hic is still being counted is on screen in under 4 s, under a veil that says loading, not counting contacts.

• A file’s first open proposes which sequences are circular (§8.15). Each of the fifty longest sequences is read at its two ends and its corner, and scored as the contacts across the junction over the contacts along the diagonal at the same separation — about one on a circle, about zero on a line. At 0.2 or above the Chromosomes table’s box is ticked and a banner says so; the box’s tooltip quotes the score. Once per file, and it only ever adds a tick, so an untick stands. A map opened over a 1D browser is marked on the Sequences card too, which read the tracks’ file. A shell asks the same with chromosomix circular <map>: every sequence’s length, score and verdict as a table, the names to hand each later run of a batch as --circular.

  Each sequence is measured at the coarsest rung that still gives it a hundred bins, so on a large file the check reads a few megabytes rather than the finest rung’s index and weights.

• Declared origins (§8.15). A sequence’s replication origin is kept per file like its circle, shown 1-based in a column of the Chromosomes table, carried in a workspace and in a run’s framing, and written as --origin NAME:POS on a chromosomix line. It is typed into the column as well as set by the task, and a task never overwrites one a reader brought. Every sequence has one: its first base, shown greyed, until another is set — so arms and every task that reads the arms read from it rather than refusing.

• Base composition, a 1D task (§18.8). GC content, GC skew, AT skew and the cumulative GC skew of a loaded FASTA, as lanes that export as bigWig, bedGraph and TSV. Its bin size is the open map’s resolution unless changed, and 10 kb in a 1D browser, where a FASTA alone is enough to run it.

• Origin and terminus, a 1D task (§18.8). The turning points of the cumulative GC skew, the terminus chosen as Bacchus chooses it — nearer the matS cluster, else farther from the parS cluster, else lower in Hi-C coverage — with the sites found by the motif search. It leaves the ori and ter loci and the parS and matS sites as BED-exportable sets, the coverage smoothed by a cubic spline and the ori/ter ratio read off it, and declares the origin it found.

• ori and arms on the map (§7.5, §8.15). On a circle with an origin, ori frames the whole of it with the origin in the middle, so the secondary diagonal is the square’s antidiagonal; it stays lit while the origin is in the middle of the view, and pressed again goes back to the sequence from its first base. arms divides by the decay along both of a bacterial chromosome’s arms rather than along the diagonal alone — the X its aligned arms draw on an O/E map, and on its correlation, is divided out and its compartments are left. The key reads arm O/E; a link carries it as arms=.

  Either press keeps what the cells are — the score picker’s choice and the balancing with it — rather than starting again from the file’s own score.

  Every map of a deck takes them: a companion reads the session’s circles and origins for its own sequence of the same name, so ori frames each map across the junction; arms is each map’s own, as its O/E is — set for every map from the first map’s card while nothing is starred, and for one map from its own card while it is — and a starred companion’s card carries ori, which frames the whole deck.

• Both diagonals of a bacterial chromosome’s expected, from the score picker (§7.5, §8.15). On a view of one sequence declared circular the picker offers arm decay, right under expected: the baseline taken along the two arms, drawn — the main diagonal’s decay down each arm and the inter-arm decay either side of the secondary diagonal through the origin, the X a figure of a bacterial map is about, where expected has the main diagonal alone and averages the secondary one into it. It is the picture expected draws with arms on, made one choice: read along the arms whether or not arms is on, at its window or 50 bins, so arms greys while it is drawn, as the O/E does. Offered on a deck’s companions too, and offered or withdrawn as a circle is ticked or unticked, without a rebuild. The key says Arm decay, the caption expected along the arms, and a link carries score=armbaseline.

• Inter-arm alignment, a 2D task (§18.8). How strongly a chromosome’s two arms touch, as the secondary diagonal’s enrichment over the distance decay: a curve against distance from the origin, a track along the chromosome, and a table of each sequence’s enrichment, enrichment after detrend and reach, one row per sequence — folds over expected, the enrichment read from the origin out to the reach: 3.1× on P. aeruginosa PAK, 1.2× on E. coli, whose arms are not aligned. The reach runs until the enrichment is a fifth of its peak on log2, near where the alignment ends, rather than half of it, which sat in the middle of the fall: a time course of ParB induced in B. subtilis reads 930 kb at 15 minutes and 1.9 Mb at 45, where half the peak read 600 kb and 1.5 Mb (task version 6).

  The enrichment after detrend is the same cells over the decay along both arms — the expectation the map’s arms and Compartments divide by — read over the same stretch: a control, near 1× where that detrending works (0.93–0.97× on PAK). window along the arms (--armWindow in a shell; 50 bins) sets it.

• Compartments along both arms, and a table of their components (§18.8). An expected choice, decay along both arms; phasing by a track as well as by a gene model or GC content; and a components table of each one’s eigenvalue, its share of the contacts, and its r with the phasing signal as drawn. E1 is the largest eigenvalue’s component, always: the phasing signal signs each component and chooses none, so the GC content of the compartments E1 calls can be compared without comparing GC content with itself.

  Its of contacts column is the share of the map’s departure from expected that each component’s checkerboard carries — the same measure under either method, adding up across components (contacts in a TSV); under the correlation the matrix’s own variance stands beside it.

• Chromosome ideograms, from UCSC’s cytoBand (§8.22). A cytoBand or cytoBandIdeo is a lane of its own kind: each chromosome in view drawn as one outline — rounded telomeres, a waist at the centromere, a narrowed stalk — with its Giemsa bands inside it in their stains’ colours, the same in both themes: gneg to gpos100 from white to near-black, the centromere red, gvar hatched. The bands are on the lane’s own axis, so zoomed out the lane is the karyotype and zoomed in it is the bands under the window, each named inside itself where it fits, with the window’s bands in ISCN under the lane’s name (Xq28, Xq27.3 – q28). A yeast CEN of 118 bases is widened to six pixels so it can be seen. The card shows the stains as a key; a click on a band opens it by its ISCN name, with its position, length and stain. A band’s stain is also its score — gneg 0, gposN N — so Signal by group can split a track over light and dark bands. A cytoBand declares the genome: its bands tile every chromosome, so the file alone opens a browser at exact lengths (lengths: the cytoBand's bands on the Genome card), and one that does not tile gives the lower bound any feature file does. Beside a map on any edge, in the browser, and read by the chromosomix command.

• Bands in the locus box (§8.22). Typing a band’s ISCN name — Xq13, chr8q24 — lists the bands of every loaded ideogram that start with it, under the gene model’s hits, and Enter opens one, padded as a gene is. A karyotype never becomes the set the gene search reads, however early it was loaded.

• RNA-seq splice junctions, drawn as sashimi arcs (§8.23). STAR’s SJ.out.tab, the two-block BED12 that regtools, TopHat and Portcullis write, and leafcutter’s .junc are read as one lane of introns, each an arc from one exon’s end to the next’s start, as tall as its read count and labelled with it at its apex. A file with junctions on both strands splits the lane: forward arcs rise from the middle, reverse arcs hang from it. The arcs are measured against the lane’s limits — a typed pair holds across windows and lanes, so two samples compare on one axis, and its floor is the minimum junction coverage; under auto the axis is fitted to the junctions in view and the caption says so (20 junctions · to 23 reads). An intron too narrow to be an arc is a spike, so a whole chromosome is a map of where splicing is. A click on an arc opens the junction: intron, intron length, strand, reads, and STAR’s multi-mapped reads, motif, whether the GTF knew it and its longest overhang — each of which the colour picker offers, so colour by annotated shows the novel junctions. The ceiling drag, ⌘-scroll, right-click range and batch box’s limits all reach the lane. STAR’s table is recognised by its columns; a BED is read as junctions where its name, a track line or its JUNC… names say so.

• A spliced BAM’s depth draws its own arcs (§8.23). The introns an alignment file’s reads skip are counted on the pass that counts its depth, under the same MAPQ floor and duplicate switch, and drawn over the curve with their counts — a sashimi plot with no junction file at all. The depth row’s card has junction arcs and from N reads (two by default); on by default, and a DNA library’s lane is unchanged, since its reads skip nothing. Long CIGARs are read from the CG tag; the strand is XS, or minimap2’s ts. Counted per record, as regtools counts, where STAR’s table counts a pair once.

• A human RNA-seq demo, and a yeast karyotype and junctions (§8.22, §8.23). Splicing on human chrX opens the 1D browser from UCSC’s hg19 cytoBand alone, at RPL10 in Xq28: the ideogram, the Ensembl chrX genes, a Geuvadis sample’s reads as depth with their arcs, and two samples’ STAR junctions (GBR and YRI) on one typed axis of 1 to 400 reads. The store lists all its files — four samples’ SJ.out.tabs from a one-pass STAR run, the BAM, and the regtools BED of the same sample — and the yeast set gains Yeast_cytobands.txt (arms, the CEN elements found in the demo FASTA, and the rDNA as a stalk) and STAR’s junctions for nf-core’s chromosome I subset, EFB1’s intron among them. scripts/make_ideogram_junction_demo.py writes them and records where each came from.

• A feature lane’s rows can be expanded, squished or collapsed (§8.16). Expanded is the rows with names under them, as before; squished packs many thin rows with no names, so a crowded stretch shows every overlapping feature; collapsed puts everything in one row across the lane. In the card, as rows, and in the lane’s right-click menu, which now also carries the strand points as a switch — both ticked where they are in force — and, opened on a feature, that feature: its card, its name and position to copy, and in the 1D browser a zoom that frames it.

• A points style for tracks (§8.8). A dot per value and nothing between them — a Manhattan plot’s picture, for p-values, sparse scores and anything whose outliers are the reading. From each pixel’s mean like the other styles, so the same limits, groups and flip apply; one dot per run of equal values, so a zoomed-in bin is one point at its middle. In the style picker of every track, in the batch box, beside the map, in the 1D browser and in figures.

• A 1D browser has a Chromosomes table (§5.8). The trail’s root picks between it and the whole genome. Circles are ticked and origins typed there with no map open, and a map opened over the browser takes them for its sequences of the same names.

• A mark is edited in its row (§8.1). A press on a mark’s place on the Manual annotations card turns it into the adding form’s boxes (and a line’s axis); Enter moves the mark in place, keeping its colour and its position in the list, and Escape leaves it.

• Manual annotations can be imported (§8.1). The card had a way out and no way back in: an Import section above Export now takes a BED or BEDPE — clicked, or dropped anywhere on the card. A BED row is a line on the axis its name column says; a BEDPE row is an arrowhead when both anchors are one base wide and a rectangle otherwise, so the card’s own exports round-trip. Marks already on the map are not added twice, and a line under the zone says what each file gave.

• Peak calling, a 1D task (§18.8, §18.9). yapc (Jänes et al. 2018) ported: a peak is where a coverage track’s smoothed second derivative turns negative — where the signal curves down — found by its shape rather than its height, so it needs no background model of normalised signal and splits two summits on one shoulder. Choose a replicate and IDR (Boley’s idr 2.0.3, the implementation ENCODE uses) tests every peak against it, keeping those at or below one of yapc’s six thresholds; with one track the peaks are ranked by curvature, the run says no test was made, and a violin of every candidate’s curvature shows where the two populations part. Out come the peaks with their summits (BED on export), a table per sequence, the six thresholds with the peaks each keeps, and a row per peak on request. Reads every base in windows of 256 kb, so a genome is never held whole, with no map needed, and runs from chromosomix peaks --signal … [--replicate …]. Held to yapc’s and IDR’s own output on the demo data, region for region and cut for cut (npm run fixtures:analysis -- --only yapc yapc_idr idr, in the environment its script describes).

• Signal by group, a 1D task (§18.8). Any track compared between groups of the genome: a feature set’s intervals split by name, strand or score (A against B on a compartment call, with the rest of the genome as a group), or a track’s bins cut by sign or into quantiles. Per group a summary and a violin; between groups Mann–Whitney and Kruskal–Wallis with effect sizes and q-values; a row per feature on request. Runs with no map, and from the chromosomix command.

  P and q are written in scientific notation where four places would print a zero, in the drawer and in an exported TSV alike (6.5319e-22).

• Compartments by cooltools’ method, by default, as well as Lieberman-Aiden’s (§18.8). A method dropdown, cooltools by default — observed/expected itself, clipped at its 99.9th percentile, less one, its gaps read as expected, and each eigenvector scaled by √|λ| — or Lieberman-Aiden 2009, the correlation of observed/expected decomposed, which is what every earlier version computed. cooltools’ agrees with cooltools.eigs_cis to |r| = 1.000 on the zoo’s maps, and skips the correlation, so a fine map takes seconds rather than minutes. A run by the correlation says so in its label. chromosomix compartments --method correlation; scripts/dbz-store.sh takes COMPARTMENTS_METHOD, the DBZ notebook METHOD.

• A .pairs for P(s)’s four orientations is dropped on the form, or chosen through it (§18.8). Under four orientations the drawer asked for the file by address alone, so a reader with the .pairs on their disk had to host it somewhere first — or drop it on the app, which opens it, as a map, behind the binning dialog. The .pairs file row is now the Tracks card’s drop area, and pressing it opens the file picker; it takes a row dragged out of the Files column as well, and keeps the drop for itself. The file is read in the analysis worker for its records alone — nothing is binned and no map changes — and its name is what the run records and what chromosomix --pairsUri is written with. The address box stays under the area for a file that is not on this computer, and replaces a dropped file when one is typed; a word that is not an address is refused under it rather than failing the run. A file is kept for the session, across the drawer’s tasks, and a name recalled after a reload, whose file is gone, empties the area rather than reaching the worker.

• Find a motif allows mismatches (§18.8), up to four, and says so in the set’s name.

• The 4C task can leave the anchor out (§18.8). Exclude anchor region empties the anchor’s own bins and one either side, so the diagonal’s spike no longer sets the scale the rest of the profile is read on.

• Run on every map, the tables come together too (§18.7). The all maps tab drew the curves of every map on one axis and sent the tables back to the per-map tabs; it now shows each table as one: every map’s rows in the deck’s order, under a first column naming the map. Inter-arm alignment run over eight libraries is one table of eight maps’ enrichments, sortable and exportable, rather than eight tabs to copy a row out of. A reproducibility run already compares every map with every other, so its matrix, tables and lines are shown once, from the run that compared the most maps, where the overlay drew each pair twice under the names of the two runs that computed it. The tab’s TSV — the tables’ and the overlays’ — carries every map’s provenance, one block per map above the numbers.

• With no map starred, no task runs (§18.1). The Analysis column says so once, above its cards — no map is starred, so no task can run — greys every row with that sentence in its tooltip, and the drawer’s Run and run on all refuse with it. Starring a map puts them back.

• A second way to build a model, and it is now the default: pastis-NB (§25.6). Model from the map gains a method control offering the two positions the literature actually takes on what a contact count is. ShRec3D, which is what the task did before and still does when picked, reads a count as a measurement of a distance, c^(−1/α), fills in the pairs the map never counted so the matrix is complete, and places the beads by classical scaling and weighted SMACOF. pastis-NB (Varoquaux, Ay, Noble & Vert 2014; Varoquaux, Noble & Vert 2023) reads a count as a count — negative binomial, with a mean of β·d^(−α) — and returns the model that makes the counts most probable.

  Two things follow, and they are why it is the default. A zero becomes evidence rather than a problem: 0^(−1/α) is infinite, so ShRec3D has to either drop such a pair or invent a distance for it, and the invention is the one step of that pipeline that is a guess. Under a likelihood a zero is a reading — probably far, and past a point indifferent to how far, which is exactly what a pair a shallow experiment missed should say — so nothing is filled in at all. On a simulated map that is three-quarters zeros, the classical start orders the pairs at ρ = 0.22 and the likelihood brings the same beads to ρ = 0.92. And a count’s precision is in the likelihood itself, so a pair seen ten thousand times holds its beads ten thousand times as firmly with nothing weighted by hand — which is why weight pairs by is hidden under this method rather than being asked twice.

  It reads the raw counts, and the balancing goes into the mean. Not a preference — a necessity, and the one thing about this that is easy to get quietly wrong. A balanced value is a count times two weights, and overdispersion is a statement about a count: variance > mean compares a squared quantity with a linear one, so scaling the data scales the two sides differently and a balanced map is never found overdispersed, whatever it actually is. Handed balanced values the negative binomial would silently collapse back into a Poisson, on nearly every real file. So the counts stay raw and the weights go where pastis puts them — into the mean, μ = β·bᵢ·bⱼ·d^(−α) with bᵢ = 1/wᵢ. The coverage is still corrected; it is corrected in the mean rather than in the data, and the run says so in a note and in the table. A bin the balancer rejected is left out, as the balanced view of the same map leaves it out. The reported Spearman ρ is taken against raw/(bᵢbⱼ) — which is the balanced value — so it stays the number Model versus map would give and does not score the model on coverage it was right to remove.

  The dispersion is fitted from your map, per genomic separation, by the method of moments over log-spaced separation bins — pastis-NB’s one claim over pastis-PM2 being that overdispersion is not one number for a map but grows as the counts thin out with distance. The whole of the negative binomial over the Poisson turns out to be a single factor: the pull on a pair is the Poisson’s own μ − c, shrunk by r/(r + μ). Where a map shows no overdispersion the run says so in as many words — none: these counts are Poisson, so this is pastis-PM2 — rather than implying a parameter it did not measure. On a helix whose far counts were corrupted, the fitted dispersion holds the near diagonal about twice as well as a flat Poisson does.

  The fit table now names the method and reports what that method has to report: for pastis-NB, the mean’s law, how many zeros were used as evidence, the dispersion near the diagonal and far from it, the MDS start, the likelihood steps and evaluations, why the optimiser stopped, the final −log L and the fitted β. Both methods still end with Spearman’s ρ against the counts.

  The cost, said before you press Run. The estimate prices the method you picked: a likelihood evaluation is about 2.3 SMACOF passes’ worth, and a step is a line search of just over one evaluation, so pastis-NB is roughly half again the wall clock of ShRec3D for the same step count. Memory is unchanged — two n × n matrices either way, because the likelihood adds vectors and not squares: L-BFGS at depth eight keeps twenty vectors of 3n + 1 doubles, six megabytes beside a twelve-thousand-bead gigabyte, where a full quasi-Newton method’s Hessian at that size would be thirty terabytes. The whole addition is 9.7 kB minified, 3.5 kB gzipped, in the chunk the analysis panel already loads.

  Mechanics. structure/negbinom.ts is the model — dispersion, objective, gradient, fit — and structure/lbfgs.ts is a limited-memory BFGS with a strong-Wolfe line search (Nocedal & Wright 3.5/3.6), the optimiser pastis itself reaches for through SciPy. Both are pure over arrays, and both are generators: the likelihood yields between evaluations rather than between steps, because a line search is several passes over the pairs and each is as long as a SMACOF step, so the bar moves and a cancel always has somewhere to land. pastis-NB is started from the MDS model ShRec3D would have given — sixty SMACOF steps, fixed, since it has only to land in the right basin — which is pastis’ own initialisation, so the new method stands on the old one rather than replacing it. α stays the reader’s control under both, and is not fitted, so a model made here and a model made by either published tool mean the same thing by it. What is refused is named in §25.8: no restarts, no alternation between dispersion and structure, no physical unit.

• A structure gets a cell of its own (§25.3). The deck held one structure cell, so showing a second model destroyed the picture of the first — which made two models something a reader could only compare by swapping back and forth, and made a reconstruction landing wipe out the model it was to be judged against, the commonest way to lose a picture in this application. A model that arrives, dropped or computed, now opens a cell beside whatever was there; the eye on each Structures row opens a cell for that row, or closes every cell drawing it, and leaves the others standing; and a cell falling back to a model picks the first no sibling is already drawing, so a deck restored with two structure cells does not draw one picture twice. A Structures row dropped on a cell swaps that cell’s model in place, which is the other question: the eye is a model asking for a cell, the drop a cell being given a model.

  Models that arrive together — two files dropped at once, a batch of runs — open a cell each.

• One model in as many cells as you like, each a view of its own (§25.3). A structure row could be drawn in one cell and one only — the link dropped a second 3d, and the eye and the drag both refused a model already on screen — on the reasoning that two cells of one row are one picture drawn twice. They are not: a cell has its own camera, its own height and its own turn — the mirrors and the planted axes are the model’s, shared by every cell drawing it — so two cells of one model are two views of it, which is the ordinary way anybody looks at a fold. The eye still means is this model on screen; the row’s grip dropped on the cell that is to hold it is how a second view is asked for. What each cell remembers is now remembered under its seat — its place among the structure cells.

• A star on each structure cell (§25.3). The Aesthetics column holds one 3D structure card and a deck may hold several models, so the card follows a cell the reader names. It was whichever cell was built first — which a reader with two models discovers by dragging a slider and watching the other picture change, and which left the second model’s settings unreachable altogether. The same glyph and the same radio behaviour the maps’ star has, and its own star rather than theirs: a starred map is the file an analysis runs against, a starred cell is the picture this column’s settings are for. It appears only where there is a choice to make, follows the cells when the starred one is closed, and is not taken by a cell that opens — a model arriving should not move a control out from under the reader using it.

• Turn together (§25.3). A link on the camera row: every cell with it lit shares the camera’s two angles, so one drag turns them all. Only the angles travel — each cell keeps its own centre, zoom and projection — which is what makes two synced cells two views rather than one view drawn twice. Pressed on, a cell leads and the others come round to it.

• In the frame of (§25.5). A select beside compare with, naming another model: this model is turned into that one’s frame, over the beads the two share and by the same superposition, and the other is not drawn. The two are one question asked twice — where do these differ wants both on screen, is this the same fold wants them in one frame — and one control doing both put a second model in the picture of everybody who only wanted the first. Two cells each in the frame of one row, turning together, are two models in one frame showing the same face of each.

• Mirrors on the frame row (§25.5). A reconstruction from contacts is fixed only up to reflection: a model and its mirror image explain the same counts equally well, so two models of one map routinely come out in opposite hands and no rotation will ever bring one onto the other. Two toggles reflect the model across the screen or up it. The reflection is applied to the built coordinates, so picking, measuring, the labels and the vector export all follow it — a mirror at the camera would flip the picture and leave the numbers under it describing a model nobody is looking at — and it is applied before any fit, since mirroring is what makes the fit possible and fitting first would reflect the answer instead of the question.

• Replant the axes (§25.5). The centre’s arms carry a frame the reader plants: replant, on the camera row, lays them along this view — x across the screen, y up it, z out of it — so every turn after that is read against the view they were planted in, which is the question anybody asks of a gizmo. Neither the model nor the centre moves; only the frame they are read against. ⌘-click replants as it re-centres, because a centre put somewhere new is a reader saying read the model from here.

• A legend in the cell’s corner (§25.3). One row per control — the key on the left, what it does on the right — with the live row lit: drag turn, scroll zoom, ⇧ move, ⌘ centre, space fog, and a sticky mode at the top while it runs. It was one chip naming the current gesture, which told a reader who already knew the keys which key they were holding and everybody else nothing: that Shift moves the model, that ⌘ puts the centre somewhere and that Space and the wheel are the fog were facts discoverable only by pressing things. In a small cell it is the live row alone, the rest coming back while the pointer is on the picture: five rows of keys over a cell 330 pixels wide is a caption taking the corner of the thing it captions, and the moment the keys are wanted is the moment the hand is already there. Asked of the cell through a container query, since the same cell is 330 pixels four across and thirteen hundred in the enlarged viewer.

• The structure cell is resized by a bar under it (§25.3). Dragged, nudged with the arrow keys, double-clicked to give the height back to the row, and remembered per seat. A model has no axis to line up with the map’s, so it is the one cell whose height is nobody’s business but the reader’s: a deck one across put the model in a 16 rem band under a map that could be shrunk to a thumbnail, and nothing done to either of them gave the model any more room.

• The enlarged 3D viewer carries the three settings the Map card owns (§25.3, §26.3). legend, crosshair and tooltip are preferences about every picture in the app, and the card that offers them is in the column behind the dialog while a model is enlarged — so the one switch for the key the reader was looking at was the one they could not reach. They appear as a shared row on the card carrying whatever no other card in the column offers: all three while the model is enlarged, none beside a map, and the key alone beside the 1D browser. The cell also hears them change now: turning the key off on the Map card used to leave the model’s key drawn until something else happened to repaint the cell.

• A yellow bead on every telomere (§25.5). A toggle under overlays in the 3D structure card marks both ends of every chain and claims no more: a chain of one bead gets one mark, and a chain that opens with a gap is marked at the first bead that is somewhere. Drawn through the same channel a reader’s own mark is, so the beads are the same size under every drawing and every colouring, and the vector export carries them without a second road.

• A grip on every Structures row, and an empty cell that takes one (§25.3). With several models loaded, the row’s own button always meant the structure cell, wherever it happened to be. Dragging a row into an empty cell of the deck now says where as well as which, and the cell becomes a structure cell drawing that model. The drag carries the row under a type of this application’s own, so an empty cell can tell a model from a file while the drag is still in the air; its hint offers both.

  A row dropped on a structure cell that already holds a model is drawn in that cell.

• The colour scale is the reader’s (§25.5). A picker under colour by lists every colormap the application carries. The colouring’s own — the default — keeps the existing rule, that a track’s beads take the lane’s colormap and contacts take the map’s, so a bead and the picture beside it cannot disagree at the same value; choosing one overrides both. Offered only for a ramp, since a colouring by sequence or haplotype is levels and has no scale to change.

• A key for colour by manual annotations (§25.5). A row per mark, named as the Manual annotations card names it: its swatch recolours the mark itself — on the card and every map too — a click takes it off the model’s colouring and a double-click shows it alone.

• The Contact maps card lists every map, each with an eye and a grip (§16.9). Every map has a row — the first map, the compared one, and each companion under its cell’s name. A companion’s eye closes its cell and keeps the map on the card, dimmed; pressed again it opens the map in a cell — the Structures card’s eye, for maps — and its × lets it go. Every row has a grip: dragged onto a cell it exchanges a companion with that cell, and a hidden map’s, the first map’s or the compared map’s row dropped on an empty cell or a + edge opens that file there.

• Maps are reordered on the Contact maps card (§16.9). The card lists the maps in the grid’s order — the first map where its cell stands, no longer always first — and a row dragged up or down it moves the map’s cell: let go above another map’s row it goes before it, below it after it, and the arrow keys on a focused grip move it a map at a time. The maps are re-dealt among the seats maps stand in, so tracks cells, models and empty cells stay put. Run on all maps, a task works through the maps in the grid’s order, and its tabs, overlays and tables follow it.

• No map need be starred, and no structure (§16.5, §25.3). A filled star is no longer a dead button: pressed, it leaves none filled. With no map starred the Aesthetics column’s Map card sets every map of the deck at once — it says every map — all N under its title, in the warn colour, and a change there is copied onto every companion one moved setting at a time, so picking a ramp does not flatten each map’s clip onto the first one’s; match all scales and match all resolutions are greyed, there being nothing to match to. With no structure cell starred the 3D structure card sets every structure cell at once, camera presses and the turntable included, and leaves out the rows that are about one cell’s own picture (compare with, in the frame of, the measurements, the export). None lasts as long as the deck; the next deck starts starred on its first map.

• An empty cell takes a track or a structure as readily as a map (§16.9). A cell drawn with a + read drop a map here; it reads drop a map, a track or a structure, and does what it says: a row dragged from the Tracks card opens a tracks cell there drawing it (and keeps it on the maps it was on), a track file opens a tracks cell and is loaded onto it, a structure file or a row of the Structures card opens its model, and a map opens as a map. A row out of the Files panel is routed the same way, by the name of its file. The deck’s count says 2 maps · 1 empty cell rather than 2 of 3 maps, and the + edge’s note names all three.

• Rows of the Tracks and Structures cards open a cell on a + edge (§16.9). A track’s row opens a tracks cell drawing it, in the cell nearest the edge; a model’s row opens its model there and moves it, the cell it was in left empty where it stood.

• A lane dragged by its grip moves to another map, or into a cell of its own (§16.9). Let go on a rectangle round another map — they light up on every map while a lane is carried — it is drawn on that edge of that map; on a + edge, a tracks cell opens there drawing it; on an empty cell, the cell becomes the 1D browser of it; on a tracks cell, that cell draws it. Each is a move: the lane leaves the map it came from.

  The lane is one edge’s: a track drawn along two sides of a map keeps the other when one is carried away, and a lane moved between two of one map’s sides leaves a third side’s lane where it is.

  A lane in a tracks cell is carried out of it the same way — to a map’s side, a +, an empty cell or another tracks cell.

• The first cell of a deck moves and closes like any other (§16.9). Its heading has a grip, and dropping it on another cell exchanges the two, as every cell’s grip does; another cell’s grip, or a companion’s row of the Contact maps card, dropped on it does the same. Its × takes it off the screen while another cell is beside it — parked out of sight rather than closed, so the other maps go on following it and the locus box above the grid still steers the deck — and its eye on the Contact maps card, or show … in the deck’s bar, puts it back where it stood. Where it stands and whether it is hidden are remembered with the column count and travel in a saved workspace.

• A tracks cell has the structure cell’s height bar (§25.3). Drag the bar under the stack to make the cell taller or shorter, nudge it with the arrow keys, double-click it to fit the row again; each tracks cell keeps its height across a reload.

• Structure and tracks cells are renamed from their heading (§25.3). A name typed into a structure cell’s heading renames its model, on the Structures card and everywhere else it is named; a tracks cell’s heading renames the cell alone — its name in the location control, remembered per cell across a reload — and no track on it. Emptied, a tracks cell’s box goes back to its default, and a model’s keeps the name it had. A tracks cell nobody named is headed as the location control lists it, tracks 2 and tracks 3 after the first, where every one of them said tracks.

• A companion off the lead reads its own window (§16.3). A box drawn on it with Option held re-reads that window for that map — as finely as its rung and its share of the budget allow — rather than magnifying the block it already held, so one file in three cells can be a whole chromosome, a 35 Mb stretch and 6 Mb at three real resolutions. The window is a pill in the cell’s heading with widen 3× and an ×; it is remembered with the map’s looks and dropped when the chain is relinked. On a companion still on the lead the box navigates the whole deck, as it does on the first map.

• Which maps an overlay is drawn on, from its row (§8.1). A loop set, a BED of borders or a set a task called was drawn on every map of a deck: the loops called on one of six maps were circled on all six, and a batch of insulation over five drew five sets of boundaries on each. An overlay is placed per map now, as a track is, and in a deck its row has a maps field in the shape of a track’s location: a line per contact map with one mark, lit where the overlay is drawn, then every map, no map and on N of M. The batch box has it for several ticked overlays, hatched where they differ. Imported, an overlay is on the session’s own map, as a track is; a set a task called is on the map it was called from, which the drawer already said it was. A session saved before this brings its overlays back on its own map, one press of every map from where they were.

• The middle of a map is a drop target: on this map (§8.1). A fifth rectangle, lit with the four strips at a map’s edges while a file or a Tracks card row is dragged, and alone while an overlay’s row is. A file dropped there opens onto that map only — a loop set on its face, a track on its usual edge — where a file dropped in the middle of a deck’s third map used to land on the first; a row dropped there is drawn on that map as well as wherever it already was. An overlay’s row let go on one of the strips is taken the same way.

• Space recentres the map on its diagonal (§8.9). The recentre button’s press, from anywhere the keyboard is not a focused button’s, tickbox’s or field’s; it is in the shortcuts dialog, the palette and the button’s tooltip.

• ⌘ + two-finger scroll slides a map up and down (§7.2). Sideways already slid it and up and down zoomed, so moving the map up the screen needed a drag with the button held; with ⌘ held the wheel slides on both axes. A pinch (Ctrl-wheel) stays the zoom, and ⌘-scroll over a lane still sets that lane’s ceiling. The shortcuts dialog says so, and no longer claims a sideways swipe over the map goes back a page.

• The DNA Bacterial Zoo, a shipped store (§24.2, §24.3). A tile between the lab’s figures and IGV’s genomes: the lab’s Hi-C maps of bacteria, one card a species, whose button opens the map with three of its tracks under it — the HiC score, insulation, and E1 read along both arms from the replication origin — and nothing else, declaring the circles and origins they were computed with; the fold holds the map, its reference and every track, 3D model included. A session make_store.py writes places a model it is given as a structure row with maps: 3d, rather than dropping it. The store is not the Stores workflow’s to write: scripts/dbz-store.sh runs the suite over every map straight into the folder that is published — framing each first by the junction test and, where a reference is found beside it, by its base composition and its origin — and scripts/DBZ_store.py index lists that folder in place; notebooks/dbz-chromosome-figures.qmd, rendered with Quarto, draws one figure per species from the same chromosomix commands and tabulates the numbers behind them, each with its test. It lives beside its data on the lab’s bucket, so until it is uploaded the tile says that, not run the workflow. Its mark is drawn by the script that draws RSG’s, over a bacterial map — a circle whose far corners are warm, with the X of its zipped arms.

• A store can ask to be drawn as cards (§24.1, §24.2). Three optional keys on a store file: group names the field its rows belong to, headline the fields a group repeats, and "layout": "cards" draws one card per group the way IGV’s genomes are — the group’s session as the card’s button, its headline fields and track count as chips, every other row under the card’s fold, named without the card’s own name. A store read by URL was always a flat faceted list, which is the wrong shape for a shelf of seventy organisms with nineteen files each. Without layout a group folds the list under a heading per group. make_store.py check refuses a layout the viewer does not know, cards with no group, and a group no row has.

• Copy this, on the right-click menus (§7.2). On the map, on a lane beside it, on a lane of the 1D browser, and on a 3D model (a right click that does not drag): the one object under the pointer onto the clipboard as a PNG, as it is drawn on screen — the map’s cells with no axis, key, frame, overlay or pointer; the track alone with no name, range, handle or hairline; the model with no centre, key or buttons. The corner says how big it was, or why the browser would not take it. The map’s menu now opens on any file, marks or not.

• Every card moves by its heading, within a panel and between panels (§26.6). Drag a card’s heading — the strip that folds it on a press — and it lifts off the column, with a dashed slot where it will land; drop it anywhere in any open side panel. ⌥↑ / ⌥↓ on the heading’s chevron move it a place without the pointer. The arrangement is kept through every navigation, tab switch and reload, and the command palette’s Put every card back in its own panel undoes it.

• A caption switch on the Export card (§7.2). On by default. Off, a saved figure carries no caption under it (the region, file, bins, score, colour range and date) and ends at its lowest track. Shared by the map’s card and the 1D browser’s, remembered, and followed by the deck’s figure.

• Dev features: a switch in About that shows what is still being built (§29). A feature can now live on main — specified, tested and deployed like any other — and be invisible to a reader until they turn dev features on, under the version in About: no row, task, command, example or clause in a sentence gives it away, and the switch is the only trace. It is a preference kept in this browser, off by default, never on in an embed, and turning it reloads the window, keeping its tabs, so that nothing built under one answer survives into the other. The registry is one file (state/devFeatures.ts) whose names are a type, so making a feature public is deleting its line and letting the compiler name the gates it leaves behind. The command line has no switch and shows everything. The slider it is drawn as is the one toggle in the app with a knob, lit by the same rule as every other (§26.3).

• A metagenome’s General column lists its genomes, and a genome’s contigs, with ticks — a dev feature (§5.8). The Sequences card a cooler is steered from now has a metacool counterpart: over the whole metagenome, a pair or a selection it lists the Genomes, and ticking any number draws them together; inside a genome it lists that genome’s Contigs, and ticking several draws them against each other, with ↑ genomes to step back out. The genome view’s own contig list in the Aesthetics column is gone, since this one does what it did and more.

• Two sequences against each other — a dot plot, a dev feature (§28). A task in the Analysis panel’s 1D card sets one FASTA or .2bit of the session against another, or against itself: the exact 19-mers the two share, sampled to two million a set (one in about seven bases of a yeast), and the streaks they make along a diagonal — a reordering between two assemblies the line that jumps, an inversion the one that turns blue. Between two sets the streaks are kept one to one, each stretch at its best place and the grid a repeat family’s copies draw with each other left out; every one keeps them. The figure takes the drawer’s width, with each sequence’s name beside its stretch along the axis, cut short with an ellipsis where it does not fit; the streaks come out as a table and as pairs. It reads no map, and says so where the drawer names what a result was run on. On the long-read assembly of the yeast whose chromosome XVI carries the M. mycoides genome, against the genome it was built to be, it draws the fused chromosome’s four stretches as the contigs that make them, in several seconds. chromosomix dotplot --sequence a.fa --sequence b.fa --x a.fa --y b.fa runs the same. Not yet: a view of its own in the link, with the maps’ tracks on its edges.

• The dot plot is a view you can move through — a dev feature (§28.2). On screen its streaks are drawn as lines, sharp at any zoom, in a square plot at one scale on both axes: the wheel zooms about the pointer, a drag or a sideways scroll moves it, a double click shows both sets whole, and the line under it names the streak the pointer is on — both loci, its way round and its anchors — which a press keeps named. The PNG and PDF buttons draw the window on screen.

• A stage that edits the reference, in manual mode — a dev feature (§27). With dev features on, the heading says reference · as in the file before the resolution; pressing it, or Edit the reference in the palette, opens the whole map on a stage of its own, read once at up to 16,384 cells a side and one byte a cell (12,118 for the yeast micro-C at 1 kb), with a pieces bar along its top and left in each original sequence’s hue and the map’s lanes beside it. A drag along the diagonal selects a stretch, snapping to every junction and sequence edge; I turns it, C cuts, S splits, delete sets it aside with a reason, and dragging its square moves it — the map and its lanes redrawn through the edit under the hand, ⌥ copying, I turning it on the way, a whole sequence dropped on another’s end with ⇧ held joining the two. A drag off the diagonal boxes two stretches, with what two stretches admit. Every act is a step in a history with undo and redo, kept with the file, carried in a saved workspace, and counted in the heading — edited · 2 steps, with an arrow back to the file. The stage is closed by its × only: Escape lets go of the drag or the selection.

  Its sidebar is cards, bordered and raised as the panels’ are — selection, sequences, history, suggestions, export and picture — with the suggestions first in review and auto mode.

  As the read starts it says what it reads — reading the whole map for the stage: 13,735,472 stored pixels at 1 kb — and how many bins a cell pools on a shallow map.

• The session drawn through the edit of the reference — a dev feature (§27.7). Closing the stage on an edit now redraws the whole session through it: the file is opened again as the edited assembly — IV_e1 in the heading, the Chromosomes table, every view and every task — with the window carried to where its place went, and the tracks, features and marks fetched where the file has them and drawn where the edit puts them, a turned stretch’s signal mirrored and its bases complemented. A mark drawn on the edited map or tracks is kept in the file’s coordinates, so it survives the next edit and a revert; a task’s result is stale once the edit changes; the heading’s arrow puts the file back the same way. The edit is read under the reader, so the file is untouched and a view costs the rows it shows — from a .hic, only the blocks it needs. Not yet: a deck’s companions, and the command line, whose line for such a task says it measures the file as it is.

• Suggestions drawn over the map on the stage that edits the reference — a dev feature (§27.5, §27.6). The stage now says where it thinks the reference is wrong, on the picture the reader is judging it by. Its own method measures the file’s contact law and trans level in the pass that reads the picture, finds the junctions the map refuses along the diagonal and the corners where two ends meet off it, and weighs every split, turn, move and join as a trade of junctions — adjacency asked against the window’s own level, so telomeres and centromeres clustering never read as one. Each suggestion is drawn in the accent: a diamond where it cuts, with ticks on the pieces bars, a corner where two ends belong together, a number, and on hover what it would do — a turning arrow over a turned stretch, an arrow from a moved one to where it goes. Its label stands on a rail beside the map at the height of what it concerns, lit with its marks and its row in the list; the pointer snaps to its points and, in the plane, to its corners, and the readout names them. Y takes it as a step the history marks suggested, N turns it down; review works through them best first, Space held showing the map as it would be, and every answer re-ranks the rest and is kept with the file; auto applies every one at 50% or more, each a step marked auto. The yeast micro-C draws none as it is; a stretch turned by hand draws one, to turn it back, at 98%. Not yet: the evidence beyond the map other than the assembly’s own sequence.

  They are counted in the reader’s worker after every edit and answer, so dragging, zooming and answering are never held up by them; auto mode waits for each count, and until the first is in the card says it is weighing.

  What the answers taught — the weights, the count, what was turned down — is kept with the file and carried in a saved workspace and a shared link; on a metagenome so is each genome’s edit and its learning.

• The edit of the reference written out, and read back — a dev feature (§27.8). The stage has an export card: the edited assembly as an AGP 2.1 (the steps in its header, each gap typed scaffold with proximity_ligation as its evidence), a chrom.sizes, a Juicebox .assembly for JBAT, 3D-DNA and YaHS, and a liftOver chain from the original coordinates to the edited ones — each through the save dialog, named after the map, the file itself never touched. A stretch set aside as unplaced is written as a sequence of its own; debris, contaminants and haplotigs are left out and named in the AGP’s comments. Lay out from an AGP or .assembly… reads either back — another tool’s scaffolds, or this app’s own — as one step of the history, undone as any step is; a file of another assembly is refused, naming the sequence the map does not have. And the session lifted through the edit: the FASTA of the edited assembly from the session’s own FASTA or .2bit, turned pieces reverse-complemented; the map as an .mcool, coarsest rung first within 60 million pixels, raw counts in the edited bins; and any track — a signal as bigWig, features as BED, pairs as BEDPE — with what lay on a stretch set aside counted rather than silently lost.

• Suggestions that scaffold a real long-read assembly — a dev feature (§27.5, §27.11). Whether two contigs meet is now weighed at the picture’s own resolution — the pass that reads the stage’s picture keeps every pair of cells between sequence ends — by a score that fits the gap the assembly left between them and how much of the contact law survived beside it, walking past the cells the balancer emptied at their ends; an end has one neighbour, so a join whose ends each have a better offer counts less; and the centromeres that cluster are found from the map, so a join of two chromosomes’ telomeres — two centromeres in one sequence — is never offered at even odds. On a yeast whose chromosome XVI carries the Mycoplasma mycoides genome, assembled from long reads into 32 contigs, the stage now offers the join at the fused chromosome’s working centromere, chromosome XII across its rDNA and XV whole, and auto mode rebuilds the fused chromosome, yeast, myco, yeast, myco, in the order and orientation the strain was built to have. A suggestion says the gap it fitted (a gap of about 8 kb), an end with a better offer and two centromeres.

• The assembly’s own sequence beside the map, when the stage suggests — a dev feature (§27.5). Where the session holds the assembly’s FASTA or .2bit, the stage reads it once: the ends of every sequence for telomeric repeats — TTAGGG and its plant, insect and ciliate kin on either strand, and a budding yeast’s irregular TG₁₋₃ — and every base of a genome up to 100 Mb for gaps of N. A suggestion that would bury a telomere — a join, the turn of a chromosome’s end, a chromosome moved into another — counts against itself and says a telomere; a break beside a gap is placed at the gap, to the base, and says at a gap of N; and the side panel says what was read. On the yeast whose chromosome XVI carries the M. mycoides genome, auto mode now completes the fused chromosome from telomere to telomere. A join across a gap the map measured writes it (128,000 N between) rather than the stage’s own hundred, and the AGP writes a join’s hundred as a gap of unknown size, U.

• The stage on one genome of a metagenome — a dev feature (§27.10). On a .metacool, Edit a genome asks which — the file’s genomes longest first, each with its size, its contigs and whether it has been edited, and a filter — or takes the one in view, and opens the stage on that genome’s contigs alone: only their rows are read, and the suggestions, the auto mode and every export are that genome’s, named after it (Mock_microbial_community.metator_00009_00000.edited.agp). Each genome’s edit is kept apart from the others’. On a shallow map the stage now pools its picture until every row holds enough to see — a genome of the mock community is drawn at 11 kb rather than white at 1 kb — and the suggestions weigh what a raw map’s thinly covered cells and a pooled picture’s part-cells hold for what it is, count the contacts a suggestion rests on, and say few contacts where there are few: on the mock community they offer scaffolding joins, and no longer the rearrangements two reads of chance had lit at near certainty. Past 64 contigs, the ends weighed for a join are those that touch, not only those a corner pairs. A genome card reads every contact of the file and says how much of the genome’s stay in it, which of its contigs meet another genome more — send one there — and which contigs of other genomes, or of none, meet it most — bring one in; both are steps to undo, the AGP carries where a contig was sent, and contig → MAG writes the binning every genome’s edit makes of the file’s contigs, in the two columns DAS_Tool, anvi’o and metacooler create take.

• The session through an edit gives the file’s place beside its own, and keeps bookmarks where the file has them — a dev feature (§27.7). On a map drawn through an edit, the readout names each place with where it was in the file, as the stage’s does — IV_e1:1,159,001 ← IV:1,241,000, turned — or says it is in a gap. A bookmark taken there is kept as the same view of the file, and going back to it after the edit changed, or was put back, lands wherever the file’s stretch now is; one whose place was set aside says so. A shared link carries the edit, and the share dialog says it does: a recipient with nothing kept opens the map drawn through it.

• The stage’s pieces bars are handles — a dev feature (§27.3, §27.4). A press on a piece of the bar along the map’s top or left selects it; a drag moves it, the map rearranged under the hand as a drag of its square does, and a whole sequence dropped on another’s end with ⇧ held joins the two; a double click turns a piece; and the readout over a bar names the piece and the stretch of the file it is.

• A suggestion’s ends are dragged to adjust it, in review — a dev feature (§27.6). The ends of the suggestion review is on take the pointer: a turn’s or a move’s stretch begun or ended elsewhere, a split’s point moved, snapped as everything on the stage is, with its outline, its words and its row following the hand, and taken as adjusted. Its adjusted chip puts the ends back where the method found them.

• Name, order and start the stage’s sequences — a dev feature (§27.3, §27.4). A sequence is renamed from its pencil on the sequences card, or a double click — the fused chromosome of the reassembly auto mode rebuilds is chrXVI_Mmmyco in its AGP, not contig_39_e1 — and keeps the name through later edits; longest first orders the assembly in one step; and O starts a circle at the pointer, as the menu’s start the circle here does.

• The stage closer than its picture’s cell — a dev feature (§27.9). Zoomed in past two pixels a cell, the window on screen is read again from a finer rung, through the edit, in the reader’s worker, and painted on the picture’s own colour scale: the yeast assembly’s 10 kb picture shows its 1 kb map where the reader looks. Never finer than the map is deep enough to show, so a shallow genome of a metagenome keeps its pooled cells. The picture card says when it is shown, and offers the picture’s size — 16,384 cells a side down to 2,048 — for a faster read of a large map.

• The stage places a suggestion finer than its picture’s cell — a dev feature (§27.5). Each point a suggestion puts inside a sequence — where it splits, a turned or moved stretch’s ends, where a move puts it — is placed again at the map’s finer rungs, down to the finest it is deep enough for, by one small read around it through the edit: the cut there the map least supports. The list says each as it comes in, refined at 1 kb, and auto mode takes each as placed. On the demo scrambled at breakpoints between its 16 kb cells, every point of what the 16 kb picture suggests is put back at 1 kb — the turn’s and the move’s to the base, the split within a kilobase.

• The stage reorders without joining — a dev feature (§27.4). A piece pressed again selects its whole sequence, a stitched one whole, as a press on the sequence’s name on a pieces bar does; ↑ ↓ — or earlier and later on the selection’s card — move a whole sequence one place in the order, or a piece among its sequence’s pieces, and join nothing; and each row of the sequences card has a grip that drags the sequence to another place in the order. A stretch let go between two sequences is set there as a sequence of its own; joining is ⇧ held on the drop.

• A dot plot in the stage’s corner, redrawn through every edit — a dev feature (§27.3). With another reference loaded beside the file’s own sequence — the theoretical genome a strain was built to be — the stage draws the assembly against it in the map’s corner, and after every step the lines move with the pieces they fall in: auto mode on the chrXVI–mycoides reassembly brings the fused chromosome’s scattered contigs into one line. The streaks are found once, by the dot plot task, and only moved after that; the one under the pointer is named in the readout and a press frames it on the map. Folds away to a button, remembered.

• A stretch set aside can be put back — a dev feature (§27.4). Each row of the set-aside list on the stage’s sequences card has put back: one step, undone like any other, that returns the piece as a sequence of its own, last, as the file reads it, selected and framed to be moved into place.

Changed

• An install of the package downloads what the command runs, and no more (§22.2). echarts and three are devDependencies now: both are compiled into dist/, and the command line loads neither, so as dependencies they and zrender under them were 90 MB of the 116 MB that npm install -g chromosomix put on disk. What is left is the three the CLI’s bundle leaves external, and a test holds dependencies to exactly those. The README installs the CLI from npm — npm install -g chromosomix, or npx chromosomix@<version> for a pinned release — and keeps the clone and npm link for trying a change before it is released.

• Compartments finds its components by Lanczos iteration, in a third of the time (§18.8). Each component was found by power iteration, which converges at the ratio of the two largest eigenvalues: five hundred products of the matrix a component, seven-tenths of the task’s time on the validation’s mouse map at 100 kb — and where two eigenvalues are close in size not enough, so chr14’s third component came out a mixture of two eigenvectors. They are now found as ARPACK finds them for cooltools, by Lanczos iteration, each vector orthogonalised against every one before it and the matrix deflated by each pair found as before, to a residual within 10⁻¹² of the eigenvalue: 18 to 72 products a component on that map; and a product reads the matrix’s upper triangle alone, four rows at a time. Three components of the mouse map take 11.0 s of CPU where they took 34.8 — cooltools takes 23.0 on the same machine, each the mean of three runs of the validation’s command — and three of E. coli at 1 kb under two seconds, an eighth of what they took. E1 moves by less than 3 × 10⁻⁴, where its values reach 2, and its eigenvalue not at all; E2 and E3 agree with cooltools’ on 38 chromosome-components of 40 where they agreed on 37, chr14’s E3 among them; and a component the phasing track cannot sign — chrY’s E1, two E3s on that map, each correlating with GC content under 0.1 — may come out the other way up, its sign being the solver’s.

• A contact map’s rows come from its index, not from pixels/bin1_id (§6.2). A read of a band of rows decoded three pixel columns and now decodes two: each pixel’s row is taken from indexes/bin1_offset, which is that column run-length encoded — cooler’s own range query never reads it either. A 64-bit column is narrowed word by word rather than through a BigInt an element, straight out of h5wasm’s heap into the array handed on; and a block across the diagonal is read to the lower of its two ends, where it was read to the higher and the rows past the lower thrown away. Every task that walks a map is faster and writes the same bytes — on the validation’s mouse map, of CPU: the directionality index 7.6 → 3.9 s (domaincaller 5.8), insulation 13.0 → 7.9, P(s) 15.7 → 11.1, virtual 4C 4.0 → 2.3, raw APA 3.0 → 2.1, chromosight’s score 14.0 → 8.4, HiCRep over three maps 13.4 → 6.4 (hicrep 10.1). The deep check (§6.3) still reads the column, since checking it against the index is what it is for.

• The command line writes its tables, bedGraphs and bigWigs faster (§18.7). A bigWig’s blocks are deflated by Node’s zlib, synchronously — the library behind CompressionStream, at its settings, so the same bytes — where each of a file’s hundreds of blocks went through a stream, a blob and a response; and the rows of a table or a bedGraph are joined four thousand at a time as they are made, rather than each kept as a string to the end, which had the collector mark a quarter of a million of them again and again for every track. With the reads above, coverage of the mouse map at 10 kb — four tracks in three formats — takes 6.9 s of CPU where it took 13.1 (7.3 where it took 13.6 balanced; cooltools 15.1 and 18.5).

• The metaplot samples a bigWig in a little over half the time (§18.8, §23.1). The command line read a bigWig through generic-filehandle2‘s LocalFile, which opens the file, reads and closes it again at every read — sixteen thousand times for the validation’s metaplot over the RefSeq TSS, half of what sampling cost — and now holds one descriptor open and reads each block with one synchronous pread; reads that walk forward through the file read ahead of themselves, so a disk that has not cached the file serves them as 922 reads in order rather than sixteen thousand seeks. A window several features share — a fifth of the RefSeq TSS — is asked of the track and made into a row once. That metaplot takes 7.5 s of CPU where it took 14.1, against deepTools’ 8.4 for computeMatrix and plotProfile; over two tracks 13.6 where it took 24.3, against 21.1 with plotHeatmap. Every number is the same.

• The timings take turns: every other round runs each pair’s reference first, and there are four rounds (§18.10). notebooks/timing.qmd ran each analysis’s chromosomix commands before its references in every round, so the side that reads from the disk whatever the page cache let go since the round before was always chromosomix, and the side after it found the same input in memory: in the last published run the metaplot spent twelve seconds of its wall clock waiting on its bigWig and computeMatrix, straight after, none, and base composition twenty-four on the genome against none for bioframe. The even rounds now run each analysis’s references first, each side’s commands still in their own order, so the wait falls on each side in half the rounds; and there are four rounds by default rather than five, an even number, in the notebook and in the workflow’s runs.

• A ratio of two maps greys the O/E (§7.5). While the comparison is a ratio, the O/E toggle — and arms with it — is greyed and unlit and says why in its tooltip, and e and the palette’s entry stand down: the ratio is taken of the two maps as they are, where it was taken of each map’s O/E. A ratio is already a comparison against a baseline, the second map, and the decay with distance the two share divides out with it. The O/E setting is kept, and a split or a difference built with it on draws it again.

• P(s) leaves out the first two diagonals by default (§18.8). Minimum separation is now 2 bins rather than 0: the diagonal and the one beside it hold self-ligation and unligated fragments rather than contacts between loci, and cooltools’ expected_cis leaves them out by default (ignore_diags=2). The density is a share of a total taken over what it keeps, so its points rise by one factor; 0 brings the diagonal back, as a stored session without the setting does. The four orientations are drawn from the first record whatever the box says: they followed it, and at two bins the separation they converge at, usually shorter than one bin, would have been cut off.

• The metaplot draws a per-feature heatmap for every curve, its rows in one order (§18.8). Over several tracks — or several groups of a ranked set — it drew the first curve’s heatmap alone, so the second track’s rows were never seen. Every curve now has one, and every heatmap of a run lists the features in one order: by each one’s mean over every track, strongest first, as deepTools’ plotHeatmap orders several samples, so a row is the same feature in each and a feature strong in one track can be read off the others. Each keeps colours of its own. Over one track nothing changes. The command line writes them as metaplot-heatmap, metaplot-heatmap-2 and on, and the validation notebook holds two tracks’ heatmaps to computeMatrix and to plotHeatmap’s order.

• A ratio of two maps has no value where either map has no contacts (§6). A cell that is zero in either map is now missing, and is drawn in the colormap’s middle colour — white on RdBu_r, the colour of a ratio of one — where 4 / 0 was drawn at the top of the scale and 0 / 4 at the bottom, which on a sparse pair saturated most of the picture. A difference keeps its zeros.

• Every plot is drawn in a black frame, fitted to its data, with its legend beside it (§18.13). A chart’s plot is boxed in the ink on all four sides, its axes on the frame rather than through the other’s zero, where a dashed grey gridline along each edge was the only border; every line in a plot is solid, the gridlines half the frame’s width and the crosshair too; matrices, pileups, the metaplot’s per-feature heatmap and dot plots are framed the same way. An axis on auto now fits what is drawn instead of rounding out to the library’s whole decades — a P(s) from 5 kb to 2 Mb was drawn from 1 kb to 10 Mb: a curve’s abscissa runs from its first sample to its last, and every other fitted axis keeps a twentieth of its span at each end, its ends left unlabelled where they are not round. The ordinate fits what is in the abscissa’s window, as the window is typed, set by a task or moved with the wheel, so a P(s) opened from 4 kb no longer keeps two empty decades above itself — and a wheel along the abscissa no longer stores the ordinate’s whole extent as two typed numbers. A log axis with fewer than three decades in view is labelled between them (a P(s) zoomed inside one decade had no label at all), one of ten decades or more on whole decades every few (it had one label), and the crosshair’s numbers are spelled as the axes are — 387.3 kb, not 387,269.00. A legend down the right takes the room its names need, so it is never drawn over the plot, and a name too long for a third of the figure goes onto a second line, broken at its dots and colons. Typing one end of a window keeps the other where the fit had it.

• A browser tab keeps a connected folder for the visit only (§20.6). It was kept across reloads in Chromium tabs too; a tab is a page on whatever machine opened it, so only the installed app keeps folders now, and the connect button and the Files row say this visit in a tab.

• The metaplot’s per-feature heatmap is one smooth picture (§18.13). It was a chart of one rectangle per cell below twenty thousand cells — seams between them, a border lit under the pointer, a card naming the cell — and a grid of filled rectangles above. It is now coloured once and drawn as one image across the whole box, neighbouring rows averaged where there are more than two thousand, smoothed as it is stretched, with no frame and nothing answering the pointer; its PDF holds it as one image the viewer interpolates, and its settings offer no tooltip switch.

• The key has its ramp back, short, between its two numbers (§7.1). -4.18 ▬ -1.05: a bar 48 pixels long drawn through the colormap, as a gradient on screen and band by band in a PNG and a PDF, where the key had two squares for the ramp’s two ends. On the default ramp, which runs white, yellow, red and black, the two ends could not say which of the four a cell halfway up is.

• The lines between chromosomes are a little heavier (§7.1). The dividers (d) were drawn at metacooler show’s 0.5 and 1 or one device pixel, whichever was larger — half a pixel on a 2× screen, a hairline in a 300 dpi PNG and, inconsistently, a whole one in the PDF. They are now 1.5 CSS pixels between sequences and 2 between genomes or selection blocks, on screen, in a PNG and in the PDF alike, in the CLI’s two greys, and each is centred on the pixel grid by its own width so it stays crisp rather than smudged across three pixels.

• An aggregate peak analysis over a loop set leaves out the loops nearest the diagonal (§18.8). Nearest loop, a new setting under Separation, is coolpuppy’s mindist: a loop whose two anchors’ centres are nearer than that many bins is not piled up. It is five bins by default, and 0 piles up every loop, which is what it did before. coolpuppy’s own default, mindist='auto', is twice the half-width and two, where a window stops reaching the two diagonals left out. On the yeast demo’s 1,506 loops at the default ±21 kb window, five bins leaves out none and coolpuppy’s floor 959. The run says how many loops it left out and how near they were; at coolpuppy’s floor it keeps the same 142 of the demo map’s first 200 loops as coolpuppy, cell for cell.

• APA opens on observed / expected, and its form shows only the cards that apply (§18.2, §18.8). The normalisation starts on observed / expected rather than on distance-matched controls. The Control card, whose every setting belongs to the distance-matched control, is not drawn under any other normalisation, and the Ranking card, whose settings belong to a feature set, is not drawn for a loop set or every pair — where N and groups used to stay on screen for having been chosen on a feature set. In every task’s form, a card none of whose controls apply is not drawn.

• Track correlation leaves a window any of its tracks lacks out of every pair, as deepTools does (§18.8). It was left out of that pair alone, so each coefficient was over windows of its own: on chr19, two mouse ATAC-seq replicates beside a Hi-C insulation score — which has no value where the map is too sparse to give one — read ρ = 0.59 at 100 bp where deepTools’ plotCorrelation reads 0.54 from the same windows. Every coefficient is now over the windows every track has a value for, the replicates read 0.54 as deepTools does, and the run says how many windows it left out; compared, beside units under the matrix, says how many are left.

• The validation notebook holds ten more analyses to their references, and its timings are a notebook of their own (§18.10). notebooks/validation.qmd adds coverage and virtual 4C against cooltools, pileups — raw, over the expected and over distance-matched controls, off the diagonal and on it — against coolpuppy, the pileup’s chromosight score against chromosight quantify, Boost-HiC against its own Python, the metaplot against deepTools, interval overlap and its shuffled null against bedtools, base composition against bioframe and Biopython, the motif search against seqkit, and the track correlation against pyBigWig’s exact window means and against deepTools, on 4DN’s mouse Hi-C, ATAC-seq and insulation score, UCSC’s mm10 and RefSeq genes, and GEO’s yeast Micro-C, each fetched from where it was published. Where the reference draws at random, the two are compared as distributions, against the reference’s own spread from seed to seed. It writes every command to notebooks/work/validation/commands.json, and the new notebooks/timing.qmd runs them again, round robin, writing every run (CPU and wall-clock seconds, peak memory, the machine and the versions) to one tidy table, notebooks/work/validation/timings.tsv, from which its tables and figures are drawn. It times one seed of the controls, one virtual 4C viewpoint, Boost-HiC on chr1, and APA raw and over controls but not over the expected, and sums a side’s commands where it takes several: deepTools’ computeMatrix and plotProfile against one metaplot.

• Electron 43.2.0 → 43.7.9 (§15). Past GHSA-gr2m-v5gq-v685, GHSA-j84w-jfhq-vhvj, GHSA-qmv3-fv6v-rmhq and GHSA-9qh4-3jw8-366w, four high advisories against the version 0.13.0 shipped on. Still pinned exactly, for the reason package.json gives.

• A chart’s tooltip is the app’s own, and spells a coordinate as the axes do (§18.13). Every chart has a formatter now, written in classes rather than the library’s style= markup, which a strict policy refuses — VII, 84.3 kb, 2.24e-7, as the ticks under it read.

• The site moves to its own domain, https://chromosomix.app/. public/CNAME names it, so the deploy builds for the root and a pull request’s preview is announced at chromosomix.app/pr/<n>/; the README, the package’s homepage — which the desktop and single-file builds read the generated stores from — the docs and the publishing scripts name it, and scripts/publish-demo.sh adds it to the origins the bucket allows to make signed requests. docs/deploy.md lists the four settings outside the repository the move needs — DNS, the Pages custom domain and its certificate, the Google and Dropbox registrations, the bucket’s CORS — and the two things it cannot carry: a browser’s storage, which stays with the old address, and an installed copy, whose service worker keeps serving its last build there.

• The DNA Bacterial Zoo is a dev feature (§24.3, §29). It is published with the multi-genome format, when the metacooler project is: with the switch in About off, Connect to a data store has no tile for it. The lab’s store says it holds bacterial data, which its paper card now does.

• The app is chromosomix (§1, §23, §29.5). It was metacooler.js, with the mark (meta)cooler — named after metacooler, the Python CLI that writes .metacool files, which is a separate project and whose format is a dev feature here (§29). The header, the landing page, the tab’s title, the install prompt, the desktop app’s window and menu, and the producer a PDF, a workspace and an exported edit record say chromosomix, and every name the app gives its own things moves with it. None of the old spellings is read any more:

  • The command line is chromosomix, the app’s own name, where it was metacooler-run (dist-cli/chromosomix.mjs, npx chromosomix), and the console writes its lines under that name. Every table, BED, bed3d and console script the app or the command writes heads itself # chromosomix, then the build: the version and the commit from the app, the version and cli from the command.
  • A workspace is workspace-<stamp>.chromosomix.json, of kind: "chromosomix.workspace", and a store is kind: "chromosomix.store". A workspace, a store, a session file or a #session= link written before is refused as not one. The demo workspaces are demo/**/*.chromosomix.json, so the lab’s bucket needs scripts/publish-demo.sh and scripts/publish-store.sh again (the store’s paper card is The Chromosomix paper, in chromosomix_paper/). The DNA Bacterial Zoo needs scripts/DBZ_store.py index over its folder and a sync, and its index is now dbz/store.chromosomix.json, beside the store.json the build before the rename reads, so it can be published while the site still runs that build. The 4DN and ENCODE shelves need a run of the stores workflow.
  • What the browser keeps is under chromosomix:, and in the IndexedDB database chromosomix: the theme, the columns, connected folders and buckets, recent colours and every other remembered setting start afresh.
  • An embedding page hears chromosomix:ready and chromosomix:state, and sends chromosomix:where and chromosomix:navigate (§21.4). A drag between the app’s surfaces carries application/x-chromosomix-*, and the desktop bridge is window.chromosomixDesktop.
  • The package is chromosomix, the desktop app chromosomix.app (io.github.js2264.chromosomix), the single file chromosomix-<tag>.html, and the site and repository js2264.github.io/chromosomix/ and github.com/js2264/chromosomix.

  metacooler keeps its own meaning: the Python CLI and API (metacooler create, metacooler show), the metacooler-format attributes a .metacool carries, and the reader that mirrors that API name for name, MetaCooler (§6). METACOOLER_PYTHON still names the interpreter the fixtures are built with.

• A called set is one row, and its display says where it is drawn (§18.7, §18.8). Insulation’s boundaries and domains — and every other set a task calls: DI’s borders and domains, peaks, A/B segments, sites, origins, flagged contigs, loops — arrived as two rows each, an overlay on the map and a lane beside it, with a switch on each and both on: one insulation run put five rows on the Tracks card for three results and drew every boundary twice, on the map as a box one bin wide and as a tick beside it. Each set is now one row whose display — a dropdown at the head of its settings and under its name in the drawer — is a 1D track or a map overlay, never both. On the map a set of places has a look, a second dropdown beside the display: a point on the diagonal, or a short diagonal marker across it, ringed in the page’s colour so it reads on the darkest row; a set of extents is drawn as the corners of the squares it claims along the diagonal — top edge and right edge, once, on the upper side — where it was the whole square drawn on both sides of the line it is symmetric about; on a turned map a corner is the two sides of a triangle on the axis. Each task says where a set opens: insulation lands as three rows, the score, the boundaries as segments one bin wide under it, and the domains as corners on the map; DI the same; peaks and A/B segments open as tracks under the lane they were called from, loops and the dot plot’s streaks on the map. A set run again keeps its display, its look and its edges; the 1D browser draws every called set as a track and offers no display; a loop set’s 1D track is its anchors and it still leaves as its BEDPE. A session saved with the two rows comes back as the one, a track where its lane was on.

• A mark’s row on the 3D key hides the mark itself (§25.5). Under colour by manual annotations a click on a mark’s name hid it from that model’s colouring alone and left it on every map; it is now the mark’s own eye on the card — the mark goes from the model, the maps and the tracks together, and the card’s eye goes dark with it — and a double-click shows it alone everywhere. A model saved with marks taken off its colouring opens coloured by every drawn mark.

• The RSG lab data store is new, and in two sections (§24.2, §24.3). Demo: a yeast micro-C map at 1.6 kb with the sequence, genes, RNA-seq as a chart per gene, ATAC, MNase, shotgun, SNPs in sixteen samples and its loops; the same tracks with no map, at 5.5 kb with the six reading frames; Hi-C, micro-C and PCP of one locus in a deck of three, MNase and the genes under each; splicing on human chrX; and Gibcus et al. 2018’s mitotic Hi-C time course in three tabs of decks. Papers: the session behind this viewer’s Fig. 1 — 4DN’s mouse ES-cell Hi-C at Sox2 with CTCF, H3K27ac and H3K4me3, its insulation and its 3D model — and Meneu et al. 2025’s M. mycoides and M. pneumoniae chromosomes in yeast, with MNase, RNA-seq, Pol II and Scc1. The yeast is R64 throughout: nothing in the store, the shelf beside its map or the paste boxes’ examples names the old demo’s synthetic chromosome XIII. The files live in one folder on the bucket, demo/store/, listed with their sources in demo/store/MANIFEST.tsv, written by scripts/make_rsg_store.py and published by scripts/publish-store.sh.

• The link, the save button and the console moved next to back and forward (§5.5, §23). They follow the two history buttons in the group after the panels, and the right of the header holds only theme, shortcuts, source and about. The command bar’s sentence is cut short on one line rather than broken over two where the left side needs the room, and below 60rem the header’s last group wraps under the first instead of running under the bar.

• A whole chromosome is read and drawn one bin to a pixel up to 16,384 bins a side (§7.2, §9). The raster’s cap goes from 4,096 to 16,384, so yeast chromosome IV at 100 bp — 15,320 bins — opens whole at 100 bp and a zoom reaches single bins without another read, where it was drawn at 400 bp. How wide a window is read at its own bins is the memory guard’s call, so a smaller machine reads a smaller square and pools the rest rather than refusing. To afford it, a block’s memory budget is three quarters of what the device reports instead of half (6.4 GB on a machine reporting 8), and the raster is costed at 12 B a pixel instead of 16 — the auto-range buffer it also charged is never live beside the others. It costs time and memory: chromosome IV opens in about 45 s and 2.9 GB where it took 9 s and 235 MB. A chromosome that used to be pooled and read from a coarser rung of a ladder is now read at the open one, so mouse chr1 at 25 kb takes the open rung’s 4.3 s instead of 1.3 s, for a picture twice as fine on each axis, and the whole yeast genome of a 100 bp ladder is its 2 kb rung read whole (6,064 bins, 2 kb) where it was that rung pooled to 4 kb. A pooled read — a whole genome no rung brings under the cap, a metagenome, the overview — keeps its 4,096 cells, and so do the correlation and smoothing; smoothing on a block past 16 M cells falls back to its floor and says so.

• Space locks the map onto its diagonal, and a second press lets go (§7.2, §8.9). It used to put the view back on the diagonal once — Recentre on the diagonal — and every pan, box and zoom after it landed a little off the line again. Now it slides the view onto the diagonal at the zoom it is at and keeps it there: a drag moves it along the line by as much of the drag as points that way, a zoom (wheel, pinch, Page Up and Page Down) is about the point of the line nearest the pointer, the arrows walk along it, a sideways scroll slides down it, and an Option-drag draws its box on the diagonal as Option and Shift do. Unlocked, a sideways scroll is the columns alone, where it always followed the diagonal. The button beside the turn is the lock’s toggle, lit while it holds; the palette and the shortcuts dialog call it Diagonal lock and show its state. It is every map’s, so a deck moves as one, it holds the next sequence stepped to, and the browser remembers it, as it does Refine on zoom.

• < and > step to the neighbouring sequence, and the letters are where they read (§5.5, §5.6, §7.2, §8.10, §26.6). The sequence steps were [ and ], which a French keyboard types with AltGr — never a shortcut here — and a French Mac with ⇧⌥. < and > step on every layout: over the comma and the full stop on American and British QWERTY, so , and . step without Shift, and bare and shifted on the key of their own that AZERTY and most European keyboards have beside the left Shift — on a French or German Mac that key no longer folds Files when there is no sequence to step to, and the Files badge no longer prints it. Control with them is the tab beside this one (it was ⌘[ and ⌘]), Control on a Mac too, from a box being typed into as well. e is the O/E toggle, the breaks overlay moves to m, f is the track fill’s again, and b bookmarks the view, as the button beside go does. 0 refits from anywhere in the window — Fit the view, the 1D browser’s whole genome — rather than only once the map had been clicked, and by its place, so AZERTY’s bare à does; Home still refits the focused map. Page Up and Page Down zoom the focused map about its centre, a wheel notch a press. ? opens the shortcuts dialog (it was ⌘/ or Ctrl+/). A key a focused picture has already answered is no longer the window’s too: a dot plot’s canvas zooming on + stepped the map’s resolution with it. The desktop menu shows <, > and ?.

• The digit row folds the side columns, in the order they stand, and − / + step the resolution (§5.5, §26.6). The key left of 1 folds Files, then 1 General, 2 Annotations, 3 Aesthetics and 4 Analysis — left to right as the columns are on screen, where they were f b a m j. The row is matched by where the keys are, with or without Shift or Caps Lock, so AZERTY’s bare & é " ' are 1 to 4 and its ² is the key left of 1; on a Mac, whose ISO keyboards report that key differently, the key beside the left Shift folds Files as well. The Files badge prints what the keyboard has there — ², @ on a French Mac, a backtick on QWERTY — from Chromium’s layout map or from the reader’s own keystrokes, and its tooltips say the key left of 1. − and + are Coarser resolution and Finer resolution: the resolution bar’s stops walked one at a time from the lit one, onto a rung the reader added as onto the file’s own, stopping at both ends, and in a deck every map follows. Either half of each key does (_, =), so neither needs Shift, and an AZERTY PC’s minus is still the minus under Shift or Caps Lock, where it types a 6. The map’s canvas no longer zooms on + and − — it had the focus after any press on it, so one keystroke would have zoomed and re-read the map together — and nor does a deck’s tracks cell; the wheel, a pinch and the boxes zoom, and the 1D browser keeps its 3× pair on the two keys. The console moves to Control and the key left of 1 (ctrl-on QWERTY, Control on a Mac too), since the key alone is Files'. The desktop menu shows1` for the General panel.

• The validation notebook reads public data only, each file by its accession (§18.10). Mouse Hi-C 4DNFIOZ1TRUS and three chicken maps (4DNFIH8L6WON, 4DNFITBCUX56, 4DNFIIML46E5) from 4DN, yeast Micro-C GSE151553 from GEO, two mouse ATAC-seq replicates (4DNFIIY4QW2D, 4DNFITBRHVZE) from 4DN, and UCSC’s mm10 for GC phasing. Peak calling runs yapc’s whole pipeline, IDR included, on the two replicates (chr19); HiCRep is held to hicrep alone; the 3D model runs its default 150 steps; compartments leave chrY out of the comparison. The times table gives each chromosomix command as a fold faster than its reference, and the text the mean of those folds. The prose is cut to what a reader of the results needs. Its reference scripts are files of their own in notebooks/scripts/, rather than strings it wrote out at render time.

• A place visited again is drawn from memory (§2, §7.2, §12). Going back to a chromosome, a window or a whole genome already seen on the same map read it again — every pixel decompressed and pooled again, and whatever another read had pushed out of the source’s cache fetched again — for an answer that could not differ: on the lab’s mouse progenitors.mcool at 10 kb, chr1 → chr2 → chr1 took 3.6 s the second time, and a window of chr1 and back to the chromosome 3.7 s, with every byte in memory. The reader’s answers are now kept on the page, by question and by the map the worker holds, each with its pooled picture, and the same place comes back in under 0.4 s with no request; a place asked for again while its first read is under way waits for that read rather than starting a second. Coolers and .hic alike — the same walk’s returns on a 940 MB chicken .hic took 1.7 s and 3.1 s and take 0.3 — in a single map, every cell of a deck and a comparison’s second file, under one budget for the page: a sixteenth of the memory the device reports, 512 MiB where it says nothing, a gibibyte at most. scripts/ui-revisit.mjs drives the walk and prints the table. A resolution left and come back to finds its answers again; a total drawn to, a cell set and a failed open start afresh. The colouring writes each pixel as one word rather than four bytes — the same bytes — and takes a third less time for it. A window seen for the first time is still a read: it is drawn at a finer grid than the chromosome it was cut from, so nothing kept can draw it.

• A map opens square, and the turn is a reading you ask for (§17.2). The default was the other way round, on the argument that a band along a genomic axis is what a contact map is for — which is true of the figure and wrong about the arrival. The only blocks that can turn are single sequences, so every map the default reached was a chromosome a reader had just clicked on, and the picture changed shape as they got there. flip absent now means square, flip=true means turned, and both older spellings still parse. So a link from 0.13.0 with no flip in it — every link to a turned map, turned being the default then — now opens square; flip=1 keeps one turned.

• .metacool and .mmetacool are a dev feature (§3.2, §29.3). With the switch off, both are refused as files this viewer does not read — in the sentence any unknown HDF5 file gets, which names neither — rather than a .metacool opening as the cooler of twenty thousand contigs it also is. The refusals a plain file can meet (an unknown HDF5, a gzip, no HDF5 signature, variable bins) stop naming the format and its commands; About describes the viewer without it; the lab’s store drops the mock community’s figure and its two files; and the genomes table, the genome views and the metagenome tasks go with it, since only such a file reaches them. The page’s description and the install prompt’s no longer name it. A .metacool 0.13.0 opened, or a link to one, now opens only in a browser with the switch on.

• The chromosomix command reads a map balanced by default (§23.1). Wherever the file carries weights, as the app does — the framing and every task’s use balancing weights alike — and --no-balance reads the raw counts. --balance is refused with a pointer, since it asked for the default and a command that forgot it ran on raw counts under a framing line that said balanced; coverage keeps its own --balance, off by default. A copied command says --no-balance for an unbalanced run and nothing for a balanced one.

• A file with several resolutions opens a third of the way up them, not at its finest (§3.6, §9). An .mcool addressed at its root, a .hic named with no resolution and a zoomify ladder in an .mmetacool land on the third of six or seven rungs — the second of four or five, the finest of one or two — so a 5 GB 4DN map comes up at 25 kb rather than 1 kb, where every read is the largest the file has and the first chromosome asked for was the longest wait. The finest level is one pick away in the resolution list, and once picked it is the floor of every zoom as before; a comparison or a deck that asks for a bin size still gets it.

• The map’s level is in the General column (§7.3). One level select at the head of the Sequences / Genomes / Contigs card replaces the Map card’s level (genome, pair, a cooler’s whole genome) and the metagenome’s separate Level card.

• A sideways scroll slides a map along its diagonal (§7), rows and columns together, as the reference editor’s stage (a dev feature, new in this release) does: the diagonal stays put and the picture moves down the genome under it, where the columns alone carried it off the side of the picture within a screen. Over a turned band, and over two stretches that share no bins, it still slides along the columns.

• A line on a turned map is the V its place makes (§17.4). A line from the Manual annotations card was drawn straight up a turned map, as it is on the square, and a column of a turned picture is not a place: it crossed contacts between two other places the whole height of the band. It is drawn now as the two 45° rays of contacts its place anchors, standing on the axis at its position — the same V a pointer on a track draws there — and carries on straight down the lanes from the V’s apex. One V per band of a mirrored pair; a horizontal line is the same V, and now continues down the lanes too; and a place just off the side of the picture still draws the arm that reaches into it. A bead hovered in the structure cell is echoed on a turned map as the same V, dashed, where it was a dashed line straight up the band (§25.4).

• The map’s correlation reaches 4,096 bins a side, and takes seconds there (§7.5). Any square block the map can read can now be correlated, where it was capped at 1,500 bins: a whole bacterial genome at 1 kb, a human chromosome at 50 kb. All the pairs are one matrix product in WebAssembly, shared across the cores — from picking the score to the picture, a thousand bins in under half a second, 2,048 in under one and 4,096 in about two and a half, in Chromium on four cores. The Compartments task’s correlation is the same arithmetic and as much faster.

• The map’s correlation counts an empty pixel as zero contacts (§7.5). It left them out, as the O/E picture draws them, so it correlated each pair of rows over the cells both happened to have — not the matrix the Compartments task solves, though its note said so, and on a sparse map several times slower. The picture under the veil still draws them as paper.

• Picking a score computed from the block reads nothing (§7.5). VC, ICE, the baseline and the correlation repaint the map, where picking one re-read the whole block first; only another column of the file, or balancing, is a new read.

• The pointer over a map with the crosshair on is a ring (§5.8). Lucide’s locate, twenty pixels square (the arrowhead’s size) and centred on the hand, replaces the small open cross, and the guide lines stop at the ends of its ticks rather than running through it, so the cell under the pointer and its neighbours stay clear inside it; the gap follows the hand inside a zoomed-in cell. Over a lane or the 1D browser the small cross gives way to the arrowhead, beside the hairline with its tip on it, so the reader’s own line can be told from another surface’s pointer echoed as the same line; and with the crosshair off all three show the arrowhead.

• A turned map reports the window a square map reports (§17.1). 400 × 400 bins · 1.0 kb was printed beside IV:1,000,001-1,399,500 · 399.5 kb, which is an arithmetic a reader checks and does not get: the rotated lattice counts in half bins, so the last half bin had no column to be measured to. Every window the view reports — the line under the picture, the framing an analysis runs on, a bookmark, what the 1D browser opens at — is on the file’s own bin edges now.

• The resolution row has no dead slider. A one-rung .cool — the commonest file a lab opens — drew a greyed slider beside its single 1 kb stop, which is §8.5’s absent-not-disabled rule broken on the row every reader looks at. The row reads resolution 1 kb +, and the slider arrives with the second rung. F is gated the same way: it folded a Files column that does not exist until a folder is connected.

• The whole genome of a laddered file is drawn from a coarse rung instead of asking to download the file (§9). On a 5 GB .mcool at 25 kb, whole genome was a gate — “reads every stored pixel of the file, 5.0 GB downloaded” — beside a button to reopen the file at 500 kb. It now reads the coarsest rung whose bins fit a drawn cell and draws: 5 s after landing over the network, 4 s for a 1 GB file on disk, and a zoom inside it still refines to the rung that is open.

• Past nine rungs the resolution row is a dropdown of every rung, beside the word, in the ladder’s own order. It was a slider and one chip: between them they said how many rungs there were and which one was being read, and named the rest only to a reader who hovered the slider — so the control that saved the room was also the one that hid the ladder.

• The analysis tasks are four cards, cut by dimension (§18.8). 2D tasks, 3D tasks, 1D tasks and Metagenome, each with the frame, mark and fold every other card in every other column has, where there was one flat list under three headings. The cut is by the dimension the question is about rather than by the file it reads: aggregate peak analysis sits with the matrix it piles up rather than with the loop set that says where, and metaplot with the track it averages rather than with the features it averages over. Metagenome stays a group of its own because its four tasks are not about a dimension — a MAG is a bin of an assembly — and its card is absent on a file with no genomes, as any card whose every task is absent now is. Within a card the task that makes the thing the others read comes first, so model from the map opens the 3D card: a reader with no structure loaded has exactly one thing to do in it, and it was the third row.

• P(s) asks for no file on a map binned from a .pairs (§18.8). The import counts the four orientations in its own pass (§3.7), and the run already took them from there when the address box was left empty — but the box was on the form all the same, under a hint about leaving it empty, and read as the one thing the curves were waiting for. On such a map four orientations is now the only question, and the price beside Run says where they come from: The four orientations were counted as CG002…pairs.gz was binned. Where the file had no strand columns, or the map was opened as a matrix, the drop area is there and the price says it needs one. A refusal about the map — no sequence ticked — is no longer skipped when a .pairs is named.

• The tasks are called Compartments and Reproducibility (§18.8). The words in brackets, eigenvectors and HiCRep, named a method where every other title in the column names what is measured, and §18 already called the two tasks so; chromosomix --help lists them the same.

• Diamond insulation is cooltools’ own, to the pixel (§18.8). A bin’s score is the mean of the valid cells of the square cornered on its diagonal pixel, over the median of its sequence, in log2 — cooltools.insulation‘s log2_insulation_score — and its boundaries are cooltools’ prominences, read over the bins whose diamond holds at least diamond coverage to call of the fullest one’s cells. It was a sum over a window half a bin along, against the sequence’s mean, and agreed with cooltools only where the window was whole: r = 0.98 there, 0.82 beside a dropped bin, on mouse at 10 kb. The two ends of a sequence and the edges of a dropped row are now scored from what their diamond holds, where they were gaps, and a sequence shorter than twice the window is scored rather than refused; the coverage setting, which blanked those bins, now only keeps them out of the calls, and sits under Boundaries. Held to cooltools’ table bin for bin on the demo map (npm run fixtures:analysis -- --only insulation).

• An optional input is filled only from what the reader loaded (§18.2). The two loci an origin call leaves were the first interval set on the list and phased every compartment call after it; a computed set is chosen now and never assumed. The compartments’ phasing track and the origin call’s coverage start on none.

• The help text under an analysis control says something, or it is gone (§26.4). Every parameter in the catalogue carried a hint and a good many of them restated the label, described a default the control was already showing, or repeated the box’s own tooltip a line lower down — every one, unless you say otherwise under a column of tick boxes with every box ticked, the places to average over under a control labelled features. Eight of those are deleted. A third of the rest had grown a second or third sentence, which is a paragraph beside a control in a column whose Run button it pushes down, and those are one sentence again; a toggle may still add what its off state does, which is the one exception the rule has ever had. What is kept is what a reader cannot get from the control: what a number does to the result, what a unit means, what an empty answer means, what a mode refuses. A test now holds the one-sentence rule, which was written down and nothing enforced.

• Every matrix setting is a number of bins, or of diagonals — never kb or Mb (§18.2). A scan band, a shift, a stratum, a near-diagonal trim and the separation between two anchors are all counts of the file’s own cells: the runner’s first act on a length in base pairs was to divide it by the bin size, so the reader was doing arithmetic the run then undid, and the same typed number meant different things on two rungs of one .mcool. The scalogram’s look out to, the APA’s two control shifts and its separation range, pattern detection’s three scan distances and reproducibility’s furthest separation now ask in bins, with their defaults translated: a 100 kb control shift, which cleared a 43-bin pileup window at 1 kb and sat inside it at 10 kb, is 50 bins and clears it at every resolution. The n bins at 1 kb caption under those boxes is gone with the boxes it was for, and what a run came to in base pairs is said once by the run itself, about the file open. Two things did not move: a 1D track’s flank, sampling step or window is a length of genome and is still asked in base pairs — track correlation’s is no longer called a bin size either — and a plot’s own axes, including the .scool phasing plot’s published band edges, stay in kb and Mb.

• One shape for which sequences to run on, and it is the tick boxes (§18.2). Nine analysis tasks asked that question and they asked it two ways: four with a column of tick boxes, five — P(s), the scalogram, insulation, the directionality index and the HiC score — with a dropdown whose first option read every sequence. A reader met both shapes in one column, a row apart, for one question. The five moved onto the tick boxes, which is the answer the dropdown could not give: these three sequences, where a select could only offer every one or exactly one. Every one of them starts with every box ticked, so a genome-wide run is still what pressing Run does; one ticked box is the run a named sequence used to give, bin for bin; and pressing none now says so rather than quietly reading the whole file. On the command line the flag is --sequences I,IV where it was --region IV, and a sequence a file has not got is named in the run’s notes instead of being dropped. What stays a locus box is what a list of names cannot answer: the 4C anchor, the structure tasks’ distance to, and the reconstruction’s own box.

• The analysis framing line says one thing once (§18.4). It read 1.0 kb bins · balanced · balanced on every file with weights, because the balance flag and the score picker’s label are the same word — a stutter in the string that is copied into every provenance record and TSV header, and that reads as two normalisations having been applied. And the window in it is the display form, so the drawer’s will run on, the figure’s caption and the map’s own summary now agree character for character rather than differing by a base.

• A waiting analysis group says what it needs once, not once per row (§18.1). Ten of the sixteen tasks read the matrix, so a 1D browser session drew ten rows under ON THE MAP each carrying the identical Open a contact map — this one reads the matrix itself. — a column twice as tall as its content, in which the one gate that differed (APA’s loop set) was the hardest line in it to find. When every waiting row of a group is waiting on the same thing the sentence is printed once, under the heading; rows whose sentences differ keep their own; and every greyed row carries its reason in its tooltip either way. The sentences also take one shape now — Open a contact map., Load a structure (g3d, .3dg or bed3d)., Load a FASTA to search. — where there were five phrasings, one of them not a sentence, and one of which told a Dip-C reader holding a .3dg that their file would not do.

• The analysis drawer’s form looks like the cards it opens over (§18.2). Every field label and every select option in every task was Title-case while every label on the three panels beside it was lowercase, so the drawer read as a different application bolted to the side of this one. All of them are lowercase now, and a label is one to three words in one column down the form, so minimum separation and log bins per step stop breaking into two lines. A number keeps its unit on its line: the box filled the whole control column and dropped bins underneath itself, which is how a reader comes to type base pairs into a box that wanted bins. A single on/off button shares its label’s row instead of floating on a line of its own under a hint that was aligned with the label rather than with it.

• pick on map sits next to the locus box, which is what §18.1 always said it did. The wrapper holding the box and the button was display: contents, which dissolved it into a two-column grid — so the button wrapped onto the next row and landed in the label column, flush under distance to and reading as a form action of its own. It is also spelled the way the Manual annotations card spells it, since it is the same gesture.

• A run’s cost line is a price and nothing else (§18.6). Every scan ended progress is reported as it goes and it can be cancelled at any point — eighteen copies of a promise the progress bar and the cancel button beside it make by existing, filling the one line a reader checks before spending compute with reassurance instead of a figure. It now says what will be read, and the sentence no longer ends in a full stop that the appended request count followed with a middle dot.

• cancel is a bordered button beside run, and so are the exports (§18.1, §18.7). The control that stops a forty-second scan was borderless grey text at the far end of a row of prose, in the weight this app uses for a link; TSV, bed3d, PNG, PDF, copy provenance and copy CLI command were the same, so the buttons that get a result out of the application read as captions.

• Where a result went is one sentence for the run (§18.7). Spatial tracks makes three lanes, and three lanes were three dashed boxes each repeating the same thirty words — is one value per bin, so it is a lane rather than a picture… — with a lone TSV under each. It is now one line saying where they went and one row per output: its name and its exports. The 3D model’s note no longer opens by telling you that the thing called 3D model is a 3D model.

• A result line reads computed in 16 ms at 20:49:46. It used to print the ISO instant with its milliseconds and its Z in the middle of a sentence, which reads as machine output that has leaked; that exact stamp is what copy provenance beside it writes, and is now the line’s tooltip.

• The running line is the step, not the task’s name again. Contact probability P(s) — Reading pixels was two thirds a repeat of the heading directly above it, and pushed the one new word to the end. A one-step job now says reading pixels; a chain still names its step, where the step is news.

• A figure’s log x is a button when it is off (§18.13). It was borderless, so an unlit axis toggle was plain grey text beside a dropdown — a label, as far as the eye is concerned, in exactly the state where a reader needs to see that there is something to press. The figure settings’ tick boxes are now the same on/off button the form and the lane settings use, so one figure’s booleans have one shape, and Fit, Reset, Show all and Colours are lowercase like every other button — the last of them now reading reset colours, which is what pressing it does.

• A figure’s column heads are aligned with their columns and have names. A <th> centres itself, so every head sat over the middle of a column of left-aligned cells; and the Model from the map table’s first head was blank, which made it a sort button whose tooltip read Sort by and whose column had to be inferred from its rows. A weighted stress reads 0.0399 rather than 3.994e-2 beside a Spearman ρ of 0.881.

• Find a sequence is Find a motif. A sequence is a chromosome or a contig everywhere else in this application, so a task called Find a sequence with a field called Sequence read as “jump to chrIV” — which is the locus box’s job. The field is motif; the reference it searches is reference.

• Cis and trans per sequence draws its fractions (§18.8). The number the first table of every Hi-C paper quotes was the one output of that task with nothing to look at: a column of three-decimal numbers under a square of sequence pairs, so a reader asking is any sequence behaving unlike the rest had to scan a list of 0.99s for the one that was not — which on a four-thousand-contig metagenome nobody does. There is now a bar per sequence, in the file’s own order, and a bars per sequence setting saying whether it stands for the cis fraction, the trans fraction, or both stacked into the full bar the two make. Fractions and not counts, because a bar of raw contacts is a picture of how long each sequence is; the ordinate reads in per cent (§26.2) while the numbers stay fractions; a sequence with no contact at all is a gap rather than a zero; and the export row beneath it is every other figure’s, with the TSV naming each sequence in its first column rather than printing the index its bar stands at.

• Compartments measure a circle’s decay the short way round (§8.15). A sequence declared circular is divided by its decay measured the short way round; the task is version 3.

• A feature’s box is edged like a coverage track’s top (§8.16). With the track outline preference on — the default — every block of a BED, a peak set, a gene or a call is drawn with the hairline in the plot’s ink that runs along the top of a coverage track: beside the map, in the 1D browser and in a saved figure. Blocks that abut, a pale colour and an untranslated end against its coding span now read as shapes. A block under four pixels either way keeps its colour unedged, and the one switch turns the rule off on the tracks and the boxes together.

• A track to the left of a map grows away from it (§8.9). Left-hand lanes grew towards the matrix, pointing a profile’s peaks into the map where the same track above it points them away; they now mirror the top stack across the diagonal, as the right-hand stack mirrors the bottom one. A file dropped there, a computed track (which opens on the left) and a row placed there all start that way; a lane saved before keeps its direction. A track placed on a map it was not on starts as the lanes on that edge start where it crosses the diagonal — rather than growing into the map beside lanes that grew away, or hanging upside down in a tracks cell — and keeps its own reading on an edge that reads like its own. A track moved by two presses of its location marks — the new edge on, the old one off — is turned as one moved in one.

• A track’s location is four marks on its map’s line (§8.1). The four words — top, right, bottom, left — are four marks of the map with one edge drawn solid, beside the label with one map, and at the end of each map’s own line in a deck, where the words took a line of their own under every name. The same in the box that edits ticked tracks together.

• Features are rounded blocks that end in a point, and grow with their lane (§8.16). A stranded feature’s direction is the point on the block it ends in — a transcript’s last exon — and nothing else: the chevrons through long boxes and along introns are gone. Corners are rounded a little, and a block takes its whole row up to 22 pixels, so a taller lane draws thicker genes where they used to stop at nine and thirteen. Variants stay square.

• The crosshair toggle reaches the tracks beside a map (§5.8). Their own hairline under the pointer, and the line it carries across the map, were drawn whatever the toggle said, so turning the crosshair off took it off the map and left it on every track; a deck’s tracks cell went on following the map’s pointer the same way.

• Ticked tracks are edited together (§8.1). The box two ticks open carries a row’s settings — colour, height, style, scale, flip, limits, group, location, and opacity for overlays — showing what the ticked rows share and mixed where they differ, and writing a pick to every ticked row it applies to (a style picked over a gene model and two bigWigs lands on the two bigWigs). Limits take both bounds; auto keeps each row’s own pair. same height is the height box now, and hide turns to show when every ticked row is hidden.

• Synthetic tracks are rows of the Tracks card (§18.5). What a task computed — a profile, a called set — and a comparison of two tracks are listed with the loaded tracks, marked * after the name as a resolution the file does not store is, with the task that made them on the summary line and the provenance in the mark’s tooltip. They take every control a loaded track takes: height, style, scale, flip, limits, group, edges, and a tick box into the batch. Their exports and framing are in their settings, and a row that came back from a reload offers recompute where a file’s row offers to re-open it. The Synthetic tracks card is gone.

• A search hit names the gene, not the window it opens. NTH1 (YDR001C) · IV:449,655 was the start of a padded window — a quarter of the gene’s length before the gene begins, and a base off the locus box the click then filled. It is the feature’s own span now, in both the map’s list and the browser’s, which is the number a reader copies into a primer tool or a paper.

• A track’s name is no longer pushed under an ellipsis by a star. The outline star stood on every feature row and took the width ATAC peaks needed, so the two rows a reader has to tell apart read ATAC and ATAC p…. It appears on hover or focus; the filled one, which says which set the search reads, never hides.

  The row’s marks are tighter too, so the name keeps its room whether the star shows or not.

• Ticking two tracks shows the bar that acts on them. It was rendered under the rows, which on a list of seven put it off the bottom of the column — so ticking boxes visibly did nothing and the ticks read as highlighting. It is above the rows.

• Peak sets, BED files, loop sets and structure lanes open at 24 px rather than 16. At sixteen the lane’s own name was drawn through the calls it named and had no click target at all, because the rule that keeps a label clear of the resize border cannot be met in that height.

• Numbers on a track row are grouped, and a value range is written with an en dash. A bigWig reaching 1599 wrote 0.16 to 1599 two rows under 12,110,231 bp.

• A lane’s limits are the colour clip’s control (§8.8). Two boxes, the ⇅ mark every autoscale in the app wears — unavailable while there is nothing to go back to — and a line reading auto · 0 – 84.5. The lit auto word it replaces meant one column carried two drawings of let the data set the range, lit when on in one and greyed when on in the other. The clip’s own row now says which units each of its two numbers is in: clip (log10) over the boxes, and the score’s word after the caption’s pair.

• The Groups card’s empty state is two sentences. It was an eleven-line essay on the theory of shared limits, in a card with no control in it, pointing at a bar two panels away as “below them”. Its two mode buttons are toggles now, lit when the group is in that state: unlink offering to unlink told a reader nothing about whether the group was linked, and the picture — two axes that happen to agree — cannot say either.

• The track-height box says what the tracks are. It read 90 over lanes that were plainly 46 px tall, because it kept the last number it had applied while stretch, shrink, a group’s levelling and a drag on a lane’s border all changed the heights behind it — so a press of down from 90 made a 46-pixel track taller. It reads the lanes now, blank where they disagree, and a press starts from their middle height. Both halves of the pair beside it say they are percentages.

• The 1D browser’s bar zooms in the map’s own four steps. It had two unlabelled magnifiers at 1.8×, beside a region bar carrying ⊖10× ⊖3× ⊕3× ⊕10× on the same screen: a reader who had learnt that one press is 3× on the map got something unpredictable on the tracks, and the zoom-out stayed live with the whole genome already on screen. The four buttons are RegionView’s own, each greys itself when there is nowhere in its direction to go, and the − / + keys drive the 3× pair. The three lane-height marks have left the bar — they are the same three the Tracks card draws a few inches away, and the map’s bar never carried them.

• A tracks cell of the deck is its axis and its lanes (§25.3). Its locus box, zoom steps and summary line are gone: where to look is asked in the lead’s bar above the grid, and the cell still pans and zooms in place.

• The General column’s File card follows the star (§16.5). It describes the starred map’s file, named under its heading with the star as the Map card is, where it went on describing the first map whatever was starred.

• A file dropped on a + lands at the near end of the edge (§16.9). Below a short last row it went into the hole the press squared up, a row above the one the reader aimed at.

• The first map’s eye on the Contact maps card closes its cell in a deck (§16.9). As every other map’s eye does. It put the map down for the 1D browser, which in a deck also took every companion map away with it; outside a deck it still does that.

• A deck beside the 1D browser exports the browser too (§25.3). The deck’s figure left a gap where the tracks stood, and the browser’s Export card saved the tracks alone however much stood beside them; the card now saves the deck’s figure, as a map’s does. The bar no longer offers to match maps’ scales and resolutions in a deck that cannot hold a map, and no longer counts the browser as a map.

• Closing a contact map in the deck hides it (§16.9, §16.5). The × on a map’s own cell, and close deck, used to drop the map from the session; it now stays on the Contact maps card with its eye dark, and the eye opens it in a cell again — the card’s × is where a map is let go. The cell closes only where the map was all it held: one with tracks drawn in it stays as a tracks cell showing them, instead of parking them on the first map.

• The Aesthetics column’s Map card is the starred map’s (§16.5). Starring a companion puts its card in the column, in the first map’s place, and a setting changed there changes that map and no other; starring the first map puts its own back. A line under the card’s title names the map it sets, with its star. The turn is the one row that still reaches every map, because the lock needs every map drawn one way, and it is on every map’s card for that reason.

• A companion’s O/E and smoothing are its own, as its score already was (§16.2). They were shared with the first map and offered on its card alone, so a companion could pick its own score in its corner menu but not its own baseline or smoothing. Each map now opens on the first map’s and keeps its own from then on, remembered with its clip in the session, the workspace and the durable record. The first map’s are still the ones in the link.

• The Contact maps card asks for a second map only once there is a first. With no map open it drew two identical rectangles, the lower one offering a second map to fill the lower-left triangle — of nothing — and both opened the same file the same way. The zone is also named for what it does, Load a map into the lower triangle, so it is not mistaken for the deck’s companion cell, which is what HiCRep and the deck bar mean by a second map.

• The deck’s bar says what its controls do (§16.5). fix all scales and fix all resolutions read as repairs to a Juicebox or HiGlass user and are now match all scales / match all resolutions, the verb this app already uses for the one-off act of putting one picture on another’s footing; their tooltips are a sentence each instead of a paragraph ending in a spec citation. add a map… is add a cell…, because the row it opens also holds the 3D structure and a stack of tracks — and the tracks cell had no other road on screen, hidden behind a button promising a map. In that row, 3D structure and tracks lead with the verb their neighbours do: add a 3D structure and add a tracks cell. The × that closed the whole deck is a bordered close deck: it was the same bare mark a cell’s own close is, a finger’s width above it, and one of the two takes every companion map and the tracks loaded for them.

• The first map’s chain moved from the bar to the first map’s own heading (§16.5). Taking one cell off the shared navigation is a statement about that cell, and every companion’s chain has always sat on it; the lead’s sat in the bar, where the same glyph at two heights read as a lock over the whole deck. The three chains — the lead’s, a map’s and the tracks cell’s — now say the same two sentences and are drawn the same way, lit while a cell is following and plain while it is not, where a cell moving on its own used to have its chain greyed like a control you cannot press.

• The deck’s N across picker says cells rather than maps, since it lays out the structure and tracks cells too, and no longer prints the backticks it was written with.

• The + edges say what the cell they open can hold. Beside the 1D browser they promised “drop a cooler on one”, which is the one thing a deck with no map to follow has to refuse.

• An exported 3D model is framed by its cell’s edge (§25.7). A thin rule round the model’s picture, the weight and colour of the map’s plot border, in the deck’s figure, the card’s PNG and PDF and the clipboard — so a model zoomed past its cell reads as framed rather than floating with one side sliced off.

• The 3D structure card names the starred cell, as the Map card names the starred map (§25.3). ★ Yeast_structure under its title, where the card had a model dropdown; the line reads every structure — all N while nothing is starred, and is absent on a deck of one model. Which model a cell draws is chosen from the Structures card: its eye, or its row dropped on the cell.

• The 3D colourings are named for what they measure, and the model’s own five lead the list (§25.5). sequence, linear position along the sequence, manual annotations (was your marks, also under loops as chords), spatial distance to pinned bin and contacts with pinned bin, then haplotype, the file’s columns, tracks and feature sets. The score column colouring is gone; a session stored with it opens coloured by sequence.

• A named .g3d, .3dg or .bed3d is not sniffed at all (§25.2). The two content tests exist to tell a structure from a BED whose columns happen to be numbers, and a file that names its format has been told apart already — by the reader who named it. A name used to be spared the fractional test but not the chain test, so a model whose beads are a scatter rather than a walk — a randomised control, a draw from a null, a fragment set nobody has folded — fell through to BED and opened as a lane of boxes whose end is a coordinate in space. The row had already been sent to the Structures card by the same name, so the row and its payload disagreed about what had been loaded.

  The name is read before a single row and settles the format: a named file that turns out not to be a structure is refused as one, in its format’s words and on the card its name sent it to; and the name is read past any directories with a ?query or #fragment cut off, so a model published at a URL is as named as one on disk.

• A Structures row has one control for being drawn. The eye and a show in the deck button did the same thing, and while the cell was drawing the row the button relabelled itself shown in the deck and went on showing — so pressing the lit one, which is what anybody would do to un-show, did nothing. The eye shows and hides. Its bed3d now sits after the word export, like the Metadata card’s TSV.

• The 3D structure card is laid out like the cards above it (§25.3). Nothing on it is unlabelled any more. A grid rule had been pushing the third control of a row onto a second line in the label column, so the chords’ set appeared as a bare none under a toggle stretched across the whole card, and the fog’s depth as a slider with no name at all: loops as chords is now label, toggle and set on one line. Every slider prints the number it is at: a bead radius you cannot read is a figure you cannot reproduce in a second session or write into a methods section. The rows are in one order, each choice before the thing that modifies it: outside window now precedes the ghost opacity, which is greyed with its reason while nothing is being ghosted. The homologue picker is haplotype and the marks row is overlays, which is what the Map and Tracks cards call the same row; both used to read show. The chords’ toggle is absent while the set is none, where it was lit with nothing to show.

  A select sits on one line with its label wherever the card is wide enough to read the value, and drops the label above it only below about 15 rem — asked of the card through a container query, since it is drawn both in the Aesthetics column and in the enlarged dialog’s sidebar. A slider that only shapes what a toggle or a select arms shares that control’s row: fog carries its depth, outside window its opacity. Overlays sits beside drawn as.

• The model saves through the app’s one export row (§25.7). It was two quiet words, PNG PDF, at a fixed 300 dpi — the third export idiom on one screen, and the only one with no resolution in it, so a reader who had chosen 600 dpi in the Export card above got 300 from here and nothing said so. It is now [resolution] [format] [⭳] [⧉] like the map’s and the browser’s, with a line under it saying what was written, and the model goes to the clipboard as readily as a map does. The camera and frame rows are bordered buttons for the same reason: a grey word beside a bordered toggle reads as a caption for it, and nobody knew side could be pressed.

• Five corner buttons on the structure cell, each with its own mark (§25.3). Frame the window wears the refit mark the Map card uses and enlarge a distinct one, where two corner-bracket glyphs sat side by side and were told apart only by hovering them. The keys those buttons and the card’s camera row print are the keys that are actually bound: (f) on a card beside a deck was offering a letter that folds the Files panel. The mode badge in its corner has lost the border that made a readout look like a button nobody could press.

• The modes on a structure cell have no letters (§25.4), which is what the contract always said. e, o and m armed them while the model was enlarged — over a model, which is exactly where a bare letter gets pressed by accident — and each of the three belonged to something else, so the shortcuts dialog printed two rows for one key.

• A structure and its lanes are named with a reader’s coordinates (§25.6, §26.1). 3D model · IV:1000001-1400000 sat one line above the framing’s IV:1,000,000-1,400,000 — the one string on the Structures card with no separators in it — and Distance to IV:1000001-1400000 named a 400 kb stretch as though the distance were to a point. It is Distance to the centre of IV:1,000,001-1,400,000 now, which is what the code measures.

• The centre of rotation is shown by default, and it is a gizmo rather than a cross (§25.5). A ball at the camera’s target with three arms out of it — one per axis, a head on the positive end and a short stub on the negative, in the colours every 3D tool uses. It is where every drag turns about and where ⌘-click puts the next one, so a reader who cannot see it is turning the model about a point they have to infer from the motion; and six half-lines crossing in a dot said neither which way an axis went nor which end was the centre. A session stored before this opens with it on, which is what the stored-style reader had to be taught: axes was read as on only if the file says so, and the default arriving as its opposite for every reader who has been here before is the one way a default change reaches nobody.

• The ghost opacity starts at 0.1 rather than 0.15 (§25.3). What is outside the window should be a trace of where the rest of the genome went, not a second picture competing with the one being read.

• Ghosting is a transparency now, not a pale colour (§25.5). A ghosted bead — one outside the deck’s window, or clicked away in the key — was its own colour mixed towards the page, which on a white page reads as washed-out rather than faint, left the geometry fully opaque so it still hid whatever was behind it, and at an opacity of 0 left a page-coloured bead punching a hole in the model rather than getting out of the way. It is real alpha now: the hue is kept, what is behind shows through, and 0 is gone. The 2D painter always did it this way, so a model on screen and the same model in an exported PDF no longer disagree about what ghosting means.

• The model turns without limit (§25.5). A drag used to stop dead a hair short of the poles, so turning a globule over to see its far side ran into a wall halfway through the gesture. Both angles now wrap: the model goes over the top and keeps going. The clamp was a turntable’s convention for keeping a horizon level, and a structure has no horizon; nothing in the arithmetic needed it, the camera’s frame being orthonormal at every elevation.

• A link that names a genome on a file with none lands on the file’s chromosomes (§9). view=genome and view=pair on a cooler, a .hic or a .pairs used to end on a refusal about genomes; a region or a selection carrying a genome name now opens as the same view without it. And a locus that names no sequence of such a file is refused as not a sequence of this file, listing its sequences, where it listed an empty Genomes: [] first — ops/range.py’s sentence is kept word for word for the files that have genomes, which are the only ones it was written for. The desktop build’s Go menu says Landing table and Previous / Next sequence, words true on every file.

• A map opened with its tracks is drawn first, and laid out once (§8.6). The tracks’ rows are seated at once and their files read once the map’s first block is drawn (at most four seconds later), as is the circularity measurement; they used to share the map’s first read with a 12 MB FASTA and a 10 MB gene model, so on a 25 Mbit/s line the demo session’s map came 6.7 s after its view mounted and now comes in 2.5 s. The lane stacks keep room for rows still reading, so the map is no longer shrunk and re-fitted when the sequence lane lands last, and download progress reaches a row four times a second rather than twenty.

• A folder is connected, on every screen that offers one. The landing page said Mount a local or remote folder, the dialog it opened was titled Open a local/remote folder, and every button and every sentence about the result said connect — three verbs for one act, one of them jargon found nowhere else in the app. The heading, the dialog’s title and the Connect dialog’s four panes now use one word each: a file is opened, a folder is connected (§20, §24.2).

  So does the Files column’s own button, and the sentences pointing a reader at it name it in quotes rather than in Markdown asterisks.

• A sign-in this site cannot make no longer offers a button on the first screen. sign in to Dropbox… stood on the landing page of sites built without a Dropbox app key, and answered the press with a greyed button and the name of an environment variable; Drive had the same hole. The landing row now reads the registration as well as the build, so it offers the sign-ins that can happen — while the Connect dialog keeps every tile, because a reader who went looking for Drive is owed the sentence saying why it is not there (§24.2).

• The panes of the Connect dialog are headed by the tile you pressed — This machine, A bucket, Google Drive, Dropbox — and their buttons say sign in to, in the words the landing page used one press earlier. The bucket form’s button says connect this bucket rather than save, which promised a stored setting where what happens is the listing you came for.

• Where connected places are listed is named by its own name. Three sentences in the Connect dialog sent a reader to About → what is stored, which the About dialog has never had; the screen they meant is What this browser is remembering, in the palette’s Help group.

• A store row’s provenance is readable. The chip carrying an accession and a DOI is clipped at the card’s width, and its tooltip said what the chip was — Where the data came from — rather than what it held, so a reader who came to cite the dataset had nowhere to read the rest of it.

• Both doors in the store row are dashed. The dashed border is the row’s one cue that a tile asks for an address rather than opening a catalogue, and Connect to a UCSC hub — the door a reader is most likely to arrive at holding a URL — did not have it.

• A shipped store that has not been generated says so, however the host answers. A fork whose Stores workflow has not run got the 404 wording from one host and, from a dev server or any host that serves a page for a missing file, a red three-line diagnosis about JSON and sign-in walls instead. A store file at an address you typed still names the address, because there it is the one thing you can act on.

• The interface has one grammar, and SPECS.md §26 states it. A deep audit of every reader-facing surface found the same kinds of drift in twenty places at once — not bugs in any one panel, but disagreements between panels, which is the one class of defect no reviewer of one file can catch. Six locus boxes asked for the same thing in five phrasings; five different looks said “this is on”; bytes were spelled three ways; the two views of one genome disagreed about whether a coordinate is 0-based. §26 is now the contract for what the surfaces share — coordinates, units, toggles, words, colour, shapes — and this release brings the shared machinery into line with it.

• Coordinates a reader sees are 1-based inclusive everywhere, and a locus box accepts what it shows (§26.1). formatPosition, regionLabel, windowLabel and typedLocusToRegion join formatLocus in genome/assembly.ts as the only place a coordinate is formatted or read, and the round trip is a test: pressing Enter on the value a box is already showing cannot move the view by a base. What is typed now also takes the spellings other browsers write — an en dash, Ensembl’s .., kb and Mb — because a reader arrives by pasting.

  That includes the 1D browser’s box and the tables’, two of which said in so many words that coordinates were 0-based and half-open, as in cooler; the region in a link is unchanged, so a shared view still means what it meant.

• A locus on the command line is 1-based and inclusive, as every box in the app reads one (§26.1, §23.1). chromosomix --window, every locus a task takes (--anchor, --region, --locus) and a locus a workspace recorded that replay runs again are read as the display form and every spelling of it, digits grouped or not — --window IV:1,000,001-1,400,000 — and the console and copy CLI command write --window that way, so a line copied out of the console names the window the breadcrumb did. They were read as cooler reads them, 0-based and as written, and the console wrote its windows in that grammar to match: right in a shell, and a base away from every other locus on the screen. This changes what an existing script means. A script’s --window IV:1000000-1400000, written for the old reading, now starts one base earlier, at the base IV:1,000,000 names — on a bin edge, one bin earlier; add one to its start to keep the old window, and the same goes for a locus flag. The framing line a run records prints its window in the display form, --help says how loci are read, and --origin was 1-based already.

• Bookmarks, the genome view’s locus box and the analysis form’s locus boxes read and print coordinates 1-based (§8.10, §5.2, §18.2). The Bookmarks card printed a saved place 0-based and read what was typed the same way, so a bookmark of the window on screen read a base earlier than the breadcrumb it was saved under, and a locus pasted from IGV was saved a base to the right; it prints the display form now, reads the typed one, and a row’s own text typed back is the place it holds. The genome view’s box worded its offer itself, had no go, and handed what was typed to the region reader as written; it is every other locus box now. The analysis form’s boxes — 4C’s anchor, Spatial tracks’ distance to, the two model tasks’ sequences — were the one place in the app a locus was read as cooler’s grammar, so their own seed from the framing and anything pasted into them named a window a base later than it said, and a pick off the map had to be shifted by a base to make up for it. They hold the typed form wherever a run is kept — the form, its provenance, the console’s command, a workspace — and become cooler’s grammar only where a job is handed to its runner; a pick is written IV:1,000,001-1,010,000, and a 4C lane and a model are named that way. A run saved before this whose anchor was picked off the map starts one base (on a bin edge, one bin) earlier when it is run again.

• Every other coordinate a reader reads or types is 1-based and grouped as en-US too (§8.1, §26.1). The Manual annotations card’s rows and boxes printed and read a mark’s stored number, 0-based, and the map’s Copy coordinates put it on the clipboard that way under menu rows that named the same cell 1-based; the whole-metagenome view’s box read a contig’s coordinates as written; and an APA’s Per anchor table named an unnamed anchor by its 0-based start. The map’s tooltip, a dragged box’s ends, a read’s mate, a gene’s exons, a bead’s tooltip in the 3D cell, the Chromosomes table’s origin column and fmt.pos now group a coordinate with commas in every locale, where a German browser showed 1.162.001 beside a breadcrumb grouped with commas, and refused an origin typed the way its own box had just written one. A range that does not parse says how a locus is read, rather than calling it cooler syntax. A map’s saved figure is named after the window its caption prints, IV_1000001-1400000-<stamp>.pdf, where it was named after the link’s 0-based string, a base off the caption inside it; and a file named after a locus drops the grouping rather than turning each comma into an underscore (ui/export.ts).

• An analysis table prints a start 1-based and saves it 0-based (§18.7). FRiP’s and Group signal’s Per feature, chromosight’s patterns and the dot plot’s streaks printed their starts 0-based, the one place a coordinate on screen still did; Peaks’ row per peak held its start and summit 1-based, so the TSV saved from it, which this app reads as BED’s (§8.3), put every peak a base to the right when it was dropped back on a map. Each now holds the start as its TSV does and prints it 1-based, every start and end in them is grouped as en-US where some printed ungrouped and some in the reader’s locale, the filter finds the base printed, and the TSV’s columns line marks the column (0-based). A Peaks TSV saved before this has 1-based starts.

• Every export asks where to save, in a dialog opened in Downloads (§26.6). Figures, decks, structures, bigWigs, bedGraphs, tables, marks, the console’s script, a workspace and an .mcool used to land straight in the browser’s downloads folder under the app’s name; the platform’s Save as now opens first, in Downloads with that name ready to change, and the card says the name it was saved under. The dialog opens before the file is made, so a long export (an .mcool, a genome’s bigWig) still gets one, and a cancel skips the work. Browsers without the dialog (Firefox, Safari) keep the plain download.

• Metadata annotations sits under Manual annotations, and it and Bookmarks start folded (§8.1). The Annotations column reads Contact maps, Tracks, Structures, Manual annotations, Metadata annotations, Bookmarks; the last two are headings until pressed. Saving a view from the button beside go opens the Bookmarks card, so the row it adds is seen.

• The caption under a saved figure is quieter (§7.2). The region was written at 15 px and semibold in the page’s ink, the largest type on the figure; it is now 11 px, and the provenance under it 10 px, both in the axis labels’ grey. The 1D browser’s one-line caption matches.

• One spelling of every quantity, reachable from a worker (§26.2). src/units.ts holds it, and the four duplicate byte-and-duration formatters that had grown in the console, the pairs dialog, the lane labels and the annotations worker are gone. Byte counts are now decimal, in thousands: the 18.1 MB file your browser is downloading is called 18.1 MB here too, where it used to read 17.3 MB.

• A toggle that is off is no longer greyed (§26.3). Dimming is how this app draws a control you cannot use, so an eye, a lock or a panel fold that dimmed itself when off was saying “unavailable” in the one vocabulary a reader had already learned. Off is now drawn plain and on is lit, one rule in the stylesheet draws every toggle in the application from the ARIA state it already carried, and a test refuses a second look. Two toggles in the 3D panel that were lit nowhere at all now light.

• A price is no longer red. The cost beside a scan was drawn in the refusal colour, which in this app means “this did not happen”. Cost is a fact about what is being offered, and reads as one.

• Menus, toasts, tooltips, the modal, the feature card and the console carry the theme’s shadow. Ten floating surfaces each wrote their own ink-black box-shadow, none of which changed with the theme — so on the dark theme they sat flat against the page with a 1 px border to lift them.

• The shortcuts dialog and the command palette are two printings of one registry. Same group order, same greying of what cannot act, and the gesture tables print your platform’s modifier instead of ⌥ / Alt for you to choose from — which is also how they were able to disagree about the one gesture that genuinely differs between platforms. The palette no longer offers to open the palette. A toggle command — an overlay, a panel’s fold, a structure setting — is titled by its noun in the palette, the shortcuts dialog and the 3D cell, and wears its state as a chip, rather than being named for an outcome the eye reads as a state.

• Small-print captions and the borders you have to see now meet contrast. --text-faint on white was 4.19:1 under an 11.5 px caption, and --border-strong — the dashed drop target, a kbd’s edge, a tick on a scale — was 1.94:1 against a 3:1 bar.

• The About dialog is titled About this viewer, and says what this viewer opens. The title was the brand, which the dialog’s own style shouts in capitals — (META)COOLER — where the mark is written (meta)cooler everywhere else; and its first sentence spoke only of contact maps, while the contract says About is where a reader holding a bigWig and no map is told the application is for them too. It now names the tracks, genomes and 3D models, with or without a map (§24.2).

• The keyboard sheet fits its content. The key groups flow into columns instead of each taking a grid row, so App’s two rows no longer sit beside File’s seven with a hand’s width of nothing under them, and the dialog is wide enough for three columns — which is what kept the two gesture tables, the part a reader new to a genome browser needs most, from starting exactly at the bottom edge.

  A command row is three columns — key, thing and state — so a title stays on one line and the state chips stand in a column of their own.

• In the command palette, a key sits on its command’s line and a description on its own. The badge was centred against the whole row, so Ctrl+S was level with the second line of its paragraph and F2 half way down a seven-line one; and a short description sat beside its title while a long one dropped beneath, which gave one list two row shapes. Typing a word you can see on screen now finds the command that carries it: folder ranks Connect a local or remote folder first rather than Fold or show the General panel, and fold no longer matches Copy this plot to the clipboard through the F of FILE.

• The console’s output box is a provenance toggle. Beside a column of commands, output named the one thing it does not show — what the runs produced — and its meaning was a four-line tooltip; it is now called what it prints, and drawn as a toggle rather than a ticked box (§23.3). copy, save and clear are bordered buttons like everything else in a bar: three borderless words beside a panel’s title read as headings, and clear is the one of them that destroys something.

• A corner note no longer covers the status bar. The note that says a link was copied was anchored to the window’s own bottom-right, which is where the memory figure a reader watches during a large open lives. Its progress note opens on starting…, the one spelling of that state (§26.7), where it wrote Starting… beside two views writing the other.

• The share dialog answers in the dialog. It copied the link the moment it opened and said so in a corner note nine hundred pixels away, in different words from the ones its own copy button produces; both now write one sentence under the box.

• In dark mode the invited button in a dialog is legible. add, build the map, connect this folder and the store drawer’s count pill set white text on the dark theme’s pale accent, which is 2.59:1; they take the --on-accent token, at 7.1:1.

• Button labels are lowercase in the dialogs too — add, build the map, restore, dismiss, forget everything, zoom to it, additional settings — which is how every other button in the application spells itself (§26.4).

• No Markdown reaches an error screen. A dozen lines of advice carried backticks into the DOM, so a screen explaining that a file is broken printed them and looked broken itself; the commands are named bare, as the gate over a .scool already named them. The advice on an unexpected failure points up at the message it is about rather than down at the buttons, and the line that sent a reader to the file info panel names Binning QC in the General column, which is what the screen calls it.

• Less prose in front of a one-number form. The add a resolution dialog bracketed its box with two paragraphs, one of them about cooler zoomify --balance; the caveat §3.4 requires is one sentence, and the arithmetic is already on the verdict line under the box. The console’s empty panel, the share dialog’s opening sentence (which had no verb) and the Connect dialog’s privacy note are each shorter by a clause that was arguing rather than saying.

• Binning QC and the stored metadata are cards, and the metadata no longer changes shape with the file. Binning QC was a bare heading — argued once as “plain, like Reads and Validation”, both of which have since moved to the status bar — and the stored metadata was an uppercase iconed heading when a file held none and a small ▶ Metadata disclosure when it held some, so its absence was announced more loudly than its presence and a reader switching between two files watched that strip change its typography rather than fill and empty. Both are cards now, headed and folded like every other block in every column (§26.6), with the JSON folded away by default.

• A long value in the Genome card wraps instead of being cut off. The card was meant to scroll sideways; what a reader actually saw was http://127.0.0.1:5 and inferred from the feat chopped at the card’s edge with no ellipsis and no scrollbar drawn, which reads as a rendering fault rather than as a long path.

• The Genome minimap and the locus bar name the same window. The strip wrote the 0-based half-open range it thinks in, so the same window appeared twice on one screen with starts a base apart — under a tooltip insisting they were the same numbers. It writes the display form now, and its note is the gesture alone: the sequence count and the assembly’s length are the first two rows of the card directly above it.

• The marks you draw leave through the same export row as everything else, minus the resolution and the clipboard, because a BED is not a picture. Its options are named for the marks they write — arrowheads & rectangles (BEDPE), which is what the sub-heads above them say, rather than loops & boxes, which named the loops track two cards up.

• The row that says which axis is which can be read. The Arrowheads and Rectangles boxes put the axis in brackets after a full locus — I:340000 (columns) — and in half a 288-pixel column the brackets were the part that got cut, so the one word telling a reader which box was rows and which was columns was the one word they could not see. It goes in front now: columns I:340,000.

  Each axis box is as wide as the example it offers and takes a line of its own rather than half of one.

• One word for one thing, in the left column. A track is a track in the Tracks card’s tooltips rather than an annotation; the empty autoscale group is no group in a row as well as in the batch bar; the card-wide fader is opacity from 10 to 100, as the per-row slider has always been, instead of transparency from 0 to 90 — which had a reader subtracting to check that two controls over one value agreed. Every track row counts sequences, the word the FASTA row, the Sequences card and the minimap use, rather than contigs over a file whose breadcrumb says Chromosomes.

  Its box keeps room for 100, and it sits beside text size where the column has room for both and stacks where it has not.

• The three drop zones in the Annotations column say the same thing in the same shape. Each names its formats and then says Drop one here, or click to choose: the Tracks zone said neither that nor six of the formats it reads, so a reader holding a bedGraph or a 2bit was told this viewer would not take it, and the Structures zone said four things where its neighbours said one.

• Smaller wording. The Sequences card says 4 of 16 ticked · show the whole genome, since showing 4 of 16 under a list of nine visible rows is read as a count of the rows. A model’s provenance line no longer reads balanced · balanced. The Metadata annotations card explains the level rule only where the level actually refuses a column. The lane’s autoscale glyph carries one clause instead of a two-sentence lesson in a gesture said twice elsewhere.

• The map’s heading and its locus box print the locus a reader reads (§5.4). They showed the region string the state carries — IV:1000000-1400000 — directly above a summary line reading IV:1,000,001-1,399,500, so one screen named one window at two starts a base apart and copying a coordinate from the line into the box moved the picture by a base. Both now print IV:1,000,001-1,400,000, as the 1D browser’s box and the tracks cell’s already did, and the box converts what you type on the way in — so pressing Enter on what it is showing changes nothing, and a locus pasted from IGV, UCSC or a methods section lands on the bases it names. The box also asks for what it takes in the one phrasing every locus box uses, and carries its own go.

• The readout under the pointer on a map is 1-based, like everything else (§8.9). Hovering a bin said IV:1,162,000 while a drag from the same pixel said 1,162,001, which is the app disagreeing with itself by a base on the one number a reader writes down. The parts of that line are joined by ·, as the 1D browser’s are in the same slot; three spaces read as a separator on a wide window and as nothing at all on a narrow one. The right-click menu’s coordinates carry their thousands separators, and its second item is an arrowhead — the word the card that keeps it uses, where Loop sent a reader looking under a heading called Arrowheads.

• The Map, Tracks and Export cards arrive with the picture (§16.5). Behind the whole-genome gate they used to stand over an empty canvas, clip and all, so a reader nudged a clip, pressed the turn, saw nothing happen and concluded the card was broken. The overlays row now holds only the marks that light: the refit is an action, and as the one unlit mark in a row of seven lit ones it read as an overlay that was off — pressed, it threw the reader’s pan away. The crosshair and the hover card, which are about both pictures, are offered once per column rather than in both rows lit together.

• The map’s PDF says it is vector, and asks for no resolution (§7.2). The browser’s option has always read PDF (vector); the map’s read PDF, and a biologist who saved one for a figure and opened it in Illustrator expecting paths had been told which they were getting by one card and nothing at all by the other. It is the same kind of page: the cells one lossless image, and every axis, lane, key and caption round them paths and text. So the resolution goes while PDF is chosen, as it does beside the browser — the copy’s tooltip naming the one its PNG takes — and the PDF’s file name stops carrying a -300dpi it never had.

• The deck’s PDF is a drawing (§16.5). Each cell is drawn on the page as its own PDF draws it — a map’s cells the one image of that map, its axes, lanes, key and caption round them paths and text; the tracks, the browser as lead and a 3D model paths and text throughout — laid out by the one composition the PNG is, so the two files cannot disagree about where a cell stands. It was the 300 dpi PNG on a page: six panels’ axes and track names as pixels, in the one file meant to be restyled. Its name no longer carries a resolution.

• A 3D model’s PDF is paths, the tube included (§25.7). The tube — the representation a model opens in — left as the raster the GPU drew, on the argument that a lit surface is no path, so most models were a picture of pixels in the one file meant to be a drawing. It is now a stroke per bead along the GPU’s own curve, a darker rim under a lighter core, and the page holds what the PNG does, from the same numbers: a gap’s dashes whatever the model is drawn as, the centre of rotation, the ruler’s ticks, the depth slab, the fog and the cell’s own colours. The words on the model are one function for both files, so the PNG gains the ruler’s labels, the bookmarks and the measurements’ distances the cell shows, and the PDF’s distances are in the file’s units rather than the model’s normalised ones. The format reads PDF (vector), and the resolution goes while it is chosen.

• A chart’s colour bar keeps its ramp in a saved figure (§18.13). The replay that writes a chart into a PDF or a PNG flattened every gradient to its middle stop, and a matrix chart’s continuous colour bar is one: every exported pileup, saddle plot and cis/trans square had a key of one orange rectangle beside a picture in a hundred colours. A linear gradient is drawn as a hundred bands of its own colours now, clipped to the shape it fills.

• The dark theme reaches the landing page, the tables and the gates (§16.5). A contact map is a figure and stays light whatever the screen is, which is why the centre column pinned the light palette — but every view is mounted in that column, so a reader who chose dark got the page they open every session, the Genomes and Chromosomes tables they scroll, the whole-genome gate and the error view as a white sheet inside a dark frame, with a dark About dialog floating over it. The pin now follows the picture: a map, a browser stage or a deck’s grid keeps it, and a drop zone and a table of chromosome lengths do not.

• The theme button changes the page on the first press. The cycle was system → light → dark, so on a light machine — which is most of them — the first press selected light, repainted nothing, and left a sun icon that read as a claim the page was already light. It now goes to the opposite of what the machine is doing first, the same as the machine second, and back to following it third; the one silent step is the last one, where the monitor icon coming back says what happened. A screen reader hears the state, which it never did: the button’s accessible name was the constant “colour theme”.

• The reader’s word for a tab is tab, everywhere (§5.6). The strip said New session, the palette said Close this session over a hint that said “tab”, and the Share dialog was headed Share this session over a body that said “everything in this tab”. Three words for the thing in front of you, of which two are never shown anywhere else. Workspace survives as the every-tab file, said as Save every tab as a file.

  That includes a store row’s two verbs, the selection tray’s and the Files panel’s; IGV’s own noun stays IGV’s — IGV published no session for this genome.

  add a cell… no longer offers “the session’s 3D structure”.

• The 1D genome browser has a breadcrumb (§5.5, §5.8). genome › Whole genome › IV › 1,000,001-1,400,000, in the slot the map’s trail uses — so the row no longer appears and vanishes as the map’s eye is pressed, and “up” from a chromosome is one click in both views. On a map the last crumb is now the window alone under the sequence’s own crumb, instead of repeating the sequence name in a row that already had it and above a heading and a box printing the same string.

• The brand no longer empties the tab you press it from. chromosomix is the way home and reads as one, and it called the picker over the open session: the file let go of, the annotation worker stopped, a two-map deck and a comparison destroyed, with no confirmation and — for a dropped local file — no way back (§11, §21.3). It opens the picker in a new tab; a tab that is already empty goes straight there, since an empty tab is the picker.

• The status bar’s numbers are the tab you are looking at. Switching tabs never refreshed it, so a new empty tab showed the previous file’s READ 24.2 MB under a landing page. The two items that are about a file — the byte counter and the validation check — are now absent while no file is open, rather than a dash that never fills in and a button that silently does nothing; validation says never run (§26.7) and the offer to scan every pixel is in the panel that opens on hover instead of in a second tooltip behind it.

• One bin size, one spelling. The crumb said 1 kb while the map’s title said 1.0 kb, the File card said 1,000 bp, the whole-genome gate said “cells of about 3.0 kb” and a structure row said 1 kb two lines above 1.0 kb bins. Every bin size now goes through resolutionLabel, and fmt.bp’s decimal stays where it belongs — on a measured span. The two hand-rolled byte formatters left in the metagenome download refusal and the dense-array refusal — one of them counting in 1024s under an MB label — are fmt.bytes like everything else.

• A palette hint is one line, and it is not a footnote. Rename this tab ran to five lines with the file name in Markdown backticks that nothing renders, Save this workspace pointed at “the link button beside it” — a header button that is beside nothing in that list — and six hints cited section numbers of a document the app never links. The fold hints also explained the wrong refusal: Fold or show the Annotations panel said “a metacool carries no annotations” on an empty landing page, and said it again, undimmed, on a .cool whose Annotations column was on screen. Each hint is now computed from the state it is about.

• The zoom steps stop at a circle’s ends, as at a line’s (§5.4, §8.15). Pressed outward near the end of a declared circle they wrapped past the origin — one press from chr:10,001-30,000 came back as chr:2,990,001-50,000, the picture split at the junction — which made them a third way across the origin beside ori and a window typed across it, and the one a reader took without asking. They slide the window in at the end as on a line; a window already across the origin still widens and narrows about its own middle.

• A sideways scroll slides along the diagonal on every cis block (§7.2). A block of two stretches of one chromosome — what an Option-drag off the diagonal opens — slid its columns alone, as a trans block does, so a band one distance from the diagonal walked out from under the pointer. Rows and columns move together wherever both axes are one sequence, which keeps that band where it is; trans blocks, pictures above bin level and turned maps slide as they did.

• Refinement is a palette command, and the palette now says so (§2). The hint sent a reader to “the first button on a map’s picture row”, where they found the turn and turned their map instead: the button was pulled a release ago, because the preference is one setting for the whole window.

• “Not this time” is gone. A refusal dialog now names its subject in the title — Nothing to share, Nothing to save, Too many tabs — and is answered before the paragraph under it has been read.

• SPECS.md, the glossary and the README say what the code does. Every section of the specification was read against the source it governs and corrected where the code had moved on — defaults, labels, keys, refusals, cross-references, and what is built and what is not — and GLOSSARY.md gained the words this release brought: circular, origin and arms, drawn to a total, eye and grip, ideogram, splice junction, the stage, the console and more. The README lists the command line’s thirty-one tasks as chromosomix tasks prints them, the stores this build ships, and the desktop builds a release attaches.

• The unassigned statistic states both of its numbers whole. It read unassigned: 12,818 contigs / 9.3% of bins — a count of one thing beside a percentage of another — and then a paragraph under it gave the other half of each, so a metagenomics reader assembled either quantity from two sentences in two units. One line now: unassigned: 12,818 contigs (62.3%) · 17,178 bins (9.3%), with one clause under it saying what it is.

• The File card no longer counts a genome the table under it does not list. It said genomes 49 a hand’s width above a genomes table reading 48 rows, because __unbinned__ occupies a genome index and is not a genome (§7.4). The QC line is the one place it is counted.

• A column of numbers has one decimal count. The Genomes table printed 0.99, 1, 1.1, 1.07 down one column of quality scores, so the figures did not stand under one another and 1 read as a different kind of value from 0.99. Each numeric column is measured once and every cell in it prints to the same width.

Removed

• Match depth, on a map with a second file under the diagonal (§5.7). The switch scaled the second file’s counts so its 99th percentile met the first’s: it matched the picture, and left the number under the pointer and every task at each file’s own depth. The chevrons after the breadcrumb’s contacts box match the files themselves (§6.5). A ratio or a difference of raw counts, which the switch was on for by default, is now of the counts as drawn: across two depths, draw both files to one total first. Sessions that stored the switch open without it.

• Panning round a circular chromosome (§8.15). A pan past the end of a declared circle no longer reads its way round to the beginning: it stops at the sequence’s end, as on a line — and so does a zoom step pressed outward near an end, which wrapped past the origin (§5.4). ori is the way across the origin — it frames the whole circle with the origin in the middle — and that frame, or a window typed across the origin, is zoomed and refined inside but not slid past. The slide read a block per stretch of drag with the map frozen while each landed, and left no edge to tell how far round the reader had come.

• The size by setting (§25.3). A track whose value at each bead set the bead’s size, as a second channel beside the colour. The channel is gone with the control: every bead is the bead radius.

• The contact chords, and their threshold (§25.5). The map’s row through a pinned bead was drawn as cylinders from it to every bead above a threshold, under a pin contacts toggle. Colour by contacts with pinned bin says the same thing in the representation the model is already in, and a cage of coloured cylinders over a globule was a second answer to a question the first had answered. The colouring stays.

• The accent bar down a shown Structures row (§25.3, §26.3). The lit eye already says which models are drawn, and a second way of saying it in the row’s left gutter is a second look for one state.

• The companion’s corner menu (§16.5). The button in a companion’s bottom-left corner and the menu of score, transform, ramp and clip it opened are gone: the map’s Map card, shown in the Aesthetics column while it is starred, holds those and the rest.

• Ctrl+W / ⌘W no longer closes a tab. It is the browser’s chord for closing the window, and a reader who missed by one key lost the session rather than a tab. The command stays in the palette.

• The About dialog no longer ends with a sentence about a list it does not have. A site that publishes no build manifest drew This deployment does not publish a list of past builds. under a picker that was not there; the row takes itself away instead. A pinned build keeps its note, where the missing list is a reader stranded in an old commit and the button beside it is the way back.

• One sentence of advice on an unknown locus is gone. Genome and contig namespaces can collide; when they do, the genome wins describes the parser rather than the reader’s situation, and a name that collides never reaches that refusal.

Fixed

• A release tag that is not the package’s version builds and publishes nothing (§22.3). The release workflow’s first job now refuses a v* tag unless it is v and the version package.json carries, and every other job waits on it. v0.14.0, made by hand with GitHub’s release form on a commit still versioned 0.13.0, had the workflow set about 0.13.0 installers and pack chromosomix@0.13.0 for npm, which only a refused token kept off the registry for good. A release body that would be too long for GitHub — this one’s changelog section is 290 kB — is posted as each entry’s bold lead with a link to the section in full, rather than failing the release at its last step. And docs/deploy.md no longer tells anyone to create a release by hand: it still said the installers were built by gh release create, which the workflow stopped waiting on when it moved to the tag; it now says what a tag sets off, and what the npm token needs.

• A reader that stops reading no longer kills the command (§23). chromosomix tasks | head -1, or a less quit early, closed the pipe under the command, and Node’s report of the next write — EPIPE, EOF on Windows — went unheard: a stack trace and exit 1 the moment head had its line, and under insulation map.cool 2>&1 | head -1, where the progress on stderr is what closes, a task that died before writing a single file. Both streams now let the reader go; what was left to print is dropped and the command finishes what it was doing — all seven of that run’s files, identical to an unpiped run’s — and exits with the status it would have had.

• A track still reading goes with the map to another resolution (§8.6). A change of resolution carried a map’s tracks to the new one only once they had loaded: picking another resolution in the second or two after a store’s session opened, while its tracks were still being read, lost every one of them, there and for good. A track on its way is now carried too, and read again at the new resolution.

• A box is washed over the tracks beside a map, as it is in the 1D browser (§8.1). A stretch highlighted in the browser — a rectangle drawn on the tracks — showed there as a wash over every track and on the map as the square on its diagonal, but beside the map it turned into two small arrowheads under the tracks. The tracks beside a map now carry the same wash, over every lane of every stack, both stretches of a box off the diagonal, and in the saved figure; the arrowheads under the tracks are a loop’s alone, and a right-click anywhere inside a wash offers to hide its box.

• Every task measures a resolution you added, as the map draws it (§3.4, §18.4). With the map at 3 kb* — the file’s 1 kb bins summed three at a time — a task still read the 1 kb rung underneath, so an insulation track or a P(s) came out at 1 kb under a picture at 3. The analysis worker now reads the map summed to the resolution on screen: counts exactly, as the rung the file would store (a 1 kb rung summed to 4 kb reads as the file’s own 4 kb, pixel for pixel), and weights by the harmonic mean of the bins’ weights. The drawer says 3 kb* bins, a result goes out of date when you step off the resolution, and the console’s command carries --coarsen 3000, which chromosomix now takes too.

• Every export is on white in the dark theme too (§7.2, §16.5). A map’s PNG and PDF, a deck’s, a copied map, lane or track, and the box behind an exported key were laid on the page’s own colour, so in the dark theme they came out on near-black under ink chosen for white; and a task’s figure enlarged into the stage dialog, which follows the theme, exported dark from there. Every picture that leaves the app is now laid on white and redrawn in the light palette’s ink, wherever the figure was mounted when the button was pressed.

• Split after a ratio is drawn on the counts’ own scale again (§7.5). A ratio takes the transform, the ramp and the clip — log2 and the diverging ramp — and was to give them back when switched off, but a change of comparison rebuilds the map, and the panel that would have given them back was the one torn down: the split after a ratio stayed on log2 and blue to red, and so did a map whose second triangle was hidden under a ratio. What a derivation took over is now carried to the map built in its place, so ratio → split and ratio → difference → split end on the scale before the ratio, log10 and the default ramp on a balanced cooler; a ratio reached by a link, a reload or Back gives back the file’s defaults. Closing the first file of a comparison and swap sides carry the scale from before the ratio too.

• APA’s track aggregates stay unticked once unticked (§18.2, §18.8). With every track unticked, the next run ticked the starred one back on: the drawer hands the form its context around a run, and an empty list read as one nobody had answered. A list nobody has touched still opens on the starred track; one the reader emptied is kept empty.

• Track correlation’s windows are their exact means, and a mammalian genome at 100 bp fits in memory (§18.8). A window’s value was taken from whatever zoom level its size selected for drawing, and each record weighted by its whole width rather than by how much of the window it covers: a 17 kb record laid whole over a 10 kb window. On 4DN’s two mouse ATAC-seq replicates at 10 kb that gave r = 0.808 where the windows’ own means give 0.884. Every track is now read at its own resolution, a megabase at a time, and each record weighted by its overlap — pyBigWig’s stats(…, exact=True) — so the two replicates read 0.884, and on chr19 they and a Hi-C insulation score agree with pyBigWig’s exact means and SciPy to 5 × 10⁻⁷ at 100 bp, 1 kb and 10 kb, by both methods. A window was also an object each and a sequence one request: a single 61 Mb chromosome at 100 bp was killed for memory, and the whole mouse genome at 100 bp now takes three minutes and 2.3 GB.

• An aggregate peak analysis is now coolpuppy’s pileup wherever a window reaches the diagonal, and its observed / expected normalisation is coolpuppy’s (§18.8). A loop window that crossed the diagonal took the cells below it from the map read whole — contacts it already held above, mirrored — where coolpuppy cuts from the upper triangle and leaves them out: on 4DN’s mouse Hi-C at 10 kb, with chromosight’s 2,515 loops, the two pileups were up to ten per cent apart in the cells nearest the diagonal. Those cells are left out now, and so are the main diagonal and the one beside it, as coolpuppy leaves them out by default — diagonals left out, a new setting, 2 to begin with and 0 for every diagonal. A pileup on the diagonal keeps its whole window but for those diagonals, which is coolpuppy’s local pileup, and its P2LL — whose centre there is mostly the diagonal — falls with them: from 60 to 15 over the yeast demo’s ATAC peaks. Observed / expected was wrong off the diagonal: it divided the finished pileup by an expected looked up at each cell’s distance from the pileup’s centre, taken from the windows’ own cells, and put the centre of that loop set at 0.2 where coolpuppy puts it at 2.9. Each window is now divided, cell by cell, by its own sequence’s expected at the cell’s own diagonal — cooltools’ balanced.avg, read as a band as deep as the farthest window — before the mean. That is the pileup’s normalisation alone: the map’s own O/E (§7.5) is computed as it was. Raw, over the expected and on the diagonal, every cell agrees with coolpuppy’s to 5 × 10⁻⁶, the same cells left as gaps; a new golden, apa_diagonal, holds the task’s own runner to it on the demo map’s loops, the 55 of 200 that reach the diagonal included.

• A track named to chromosomix is no longer read whole to learn what it is (§23.1). Every file under --tracks was read into memory to look at its first four bytes before a bigWig or a .2bit was opened by range: a second a gigabyte before any run began, and a refusal for any file past 2 GiB, Node’s ceiling for one read. Four bytes are read now. A metaplot over a 957 MB ATAC-seq bigWig went from 15 s to 11, with the same numbers.

• Signing in to Dropbox opens the Files column on it (§24.9). The folder list hears about a bucket from the form that saves it and about a Drive folder from the pane that adds it, and nothing told it about a Dropbox sign-in — so the Files column, which exists only while a place is connected, never appeared: browse my Dropbox closed the dialog on the landing page with no error, and a sign-out from the dialog left a dead row behind. The sign-in and the sign-out are now passed on (browse/dropbox.ts). An expiry is not: the click that finds one says sign in to Dropbox in the column, and the column stays to show it. The first live sign-in, on chromosomix.app, found this.

• Desktop: bigWig lanes draw (§15). The bigWig reader fetches its own inflate wasm from a data: URL inside the annotations worker, and the desktop’s policy, which reaches its workers, refused it — inside the worker, so nothing in the page said so — and every bigWig lane stayed on fetching…. connect-src admits data:, which has no server behind it, and the site’s policy stays its mirror.

• A workspace, link, ?config=, embed message or saved tab naming an unknown view or transform opens (§5.5, §5.6, §21.1). The address was read by an allow-list and everything else was not: a state arriving as an object — a workspace, a share link, a ?config= file, an embed’s navigate, the durable record of a tab — was cast as it came, so view: 'banana' sat on Opening… for ever and transform: 'banana' threw on the first paint. Every one of them is now read by the hash’s own reader, which keeps what it knows and drops the rest; the twelve demo workspaces restore key for key.

• Desktop: a chart’s tooltip is styled (§15, §18.13). The desktop’s policy refused the chart library’s style= markup on every hover — seven hundred refusals over one P(s) — and left a box of bare text with its colour swatches gone.

• A .hic block larger than the block cache is handed back and not kept (§3.6). The eviction skipped the block just stored, so one oversize block stayed over the 48 MiB budget until the next was decoded.

• A read stored without its bases (*) shows no mismatches it does not have (§8.13). The mismatch walk compared the bytes after an empty sequence — its tags — with the reference as though they were bases; it now walks an aligned operation only as far as the read has bases.

• chromosomix reads its command line by what each command takes (§23.1). A flag took the word after it as its value unless that word began with --, so coverage a.cool --no-balance b.hic ran over a.cool alone with exit 0, coverage --quiet a.cool refused itself for want of a file, and --out --quiet wrote into a directory called true. A task’s on-or-off parameters and the command’s own --quiet, --no-balance and --help take nothing after them now — --stranded=false or --no-stranded turns one off — a flag that takes a value is refused without one, and a flag a command does not take is refused for replay and circular as for a task. --stranded false, the old way to turn one off, is refused with what to write instead. replay reads the files after the workspace as it reads those after --over, so --over data/*.hic replays every file rather than the first alone.

• Every compartments line the console writes runs in a shell (§23.1). --contacts is both the total a map is drawn to (§6.5) and Compartments’ own choice of contacts, and the console writes both — --contacts cis --contacts 10000000 — so the shell read cis as a total and refused the line. A word among the task’s options is the task’s and any other the total’s, so both are read from one line, and a word that is neither is refused naming the two.

• A value no form could hold is refused before any file is opened (§23.1). expected --quantity expectd ran the density and wrote # param quantity: expectd above the table, --factor= ran at nought and --rungs abc built one rung. Choices are checked against the task’s options, switches and numbers against what they can be, and what a replayed workspace recorded the same way — exit 2, with the values there are.

• Each input of one command is written under a name of its own (§23.1). coverage HCT116.rep1.cool HCT116.rep2.cool wrote HCT116.coverage.* twice, the second run’s files over the first’s, with exit 0. One input’s outputs are named as they always were; two that would share a name keep more of theirs (HCT116.rep1), then their directories (dirA_sample), then a number, and nothing one command writes is written over by it.

• A remote file is fetched first, as the README said (§23.1, §23.3). An http or https address went to stat as a path. A map, an --against, a --sequence with its .fai, --tracks, --features, --pairs, a .pairs for P(s)’s orientations and a replayed workspace are downloaded whole into $TMPDIR, with their progress on stderr, and removed when the command ends; the framing, the provenance and the outputs’ names are the address’s. The console’s note on a remote file says what the line costs rather than that a shell cannot read it.

• A figure’s PDF strokes what it fills (§7.2, §18.13). The PDF page let go of a path at the first operator that painted it, where a canvas keeps it until beginPath, so a shape filled and then stroked printed as its fill and a stroke of nothing: every exported box plot lost its outline, whiskers and median, the reader’s arrowheads came out as white halos with nothing inside, and a bar track’s outline and the 1D browser’s chips lost their borders. The page now keeps the path and writes it in front of every fill, stroke and clip, fillRect and strokeRect leave it alone, and each cell of a deck’s figure starts on an empty one.

• A place left before it was drawn is never drawn, and a colour changed while a region opened no longer leaves the previous view on screen (§5.5). Every change of view starts a render nobody waits for, and two ran side by side whenever the reader was quicker than the file. A colour change arriving while a region still waited on its contigs table repainted the view being replaced and called itself mounted, and the region’s own mount, overtaken, never drew — so the address named the region over the old picture. A second render of the same state, which a remount, a tab coming back and a closed comparison all start, ran to the end beside the first. Each render now calls off the one before it, which stops at its next step, and a repaint waits for the view it would paint to have finished mounting.

• The golden job compares the reader with Python on every run, with or without metacooler. It installed metacooler from PyPI, where there is no such package, and its fixture script defaulted to one cluster path, so it built no fixture on any run and reported green with a warning. Its public half now needs no credential:

  • the four published demo maps — a .metacool and an .mmetacool metacooler wrote, a yeast .cool, an E. coli .mcool — are fetched from the lab’s bucket (npm run fixtures:demo) and read against oracles the public cooler package recorded (npm run fixtures:demo-golden, rebuilt on every run to prove it still reads them the same);
  • the .scool, HiC-Pro, .pairs and binary .g3d fixtures, which cooler and g3dtools alone can write, are built and their eight suites run.

  The full suite over make_fixtures.py’s output runs when the METACOOLER_REPO_TOKEN secret can read metacooler’s repository, whose tests/data the script now finds through --data, $METACOOLER_TEST_DATA or a checkout beside this one. Every install, fetch and build step may still fail without failing the build, and the job’s summary names what did not run. The demo maps also run in the always-on job, copied from demo/. The metacool goldens are rebuilt from metacooler’s current devel, which records QC statistics the old ones did not.

• The request budgets run on every push, and the one that had gone red is green (§12). The fixture-free run excluded all of test/budgets/, though only requests.test.ts needs fixtures, and the BAM budget had been failing unseen since the annotations worker began reporting progress under the request’s own id: the test took that report for the answer. HiC-Pro’s suite, which no CI run had built the fixture for, still expected h5wasm’s own words for a text file the open path now refuses by name (not-hdf5).

• An archived build survives the site moving (§21). Every build on the archive branch carries the base it was built for in each asset URL, so the day the site’s base changes every one of them, the releases included, would be a blank page at its new address. The deploy now rewrites each archived build and preview whose base is not the site’s, once (scripts/archive-rebase.mjs, its rules held by test/unit/archive-base.test.ts); on every other deploy it finds nothing to do. Run against the thirty builds and one preview on the branch today, it moved all of them to /, and each opened there with no failed request.

• An area is shaded down to zero, not to the bottom of the axis (§18.13). The mark area, and fill under on a line, filled every series down to the axis’s lowest edge, so a profile dipping below zero was shaded from its peaks to the bottom of the picture and the parts below zero were lost in the fill. It now stops at zero, shading up to it where the line is below; on a log axis, which has no zero, it still fills to the axis’s edge.

• One end of a figure’s window typed takes effect on its own (§18.13). On an axis still fitting the data, x from or to waited for the other end, so a number typed into either sat in its box while the picture stayed on the whole of the data — and so did the second, since the window was still empty when it was typed. The end not typed is now the data’s own on that side.

• A tab with maps beside two or more 3D models keeps its maps when it is restored (§25.3). The watch that opens a cell for every model that arrives began at the store’s first change, which in a restore is the first row back, so every model after it opened a cell; publishing those cells wrote them over the maps the link was putting back, and a workspace tab of five maps and five models came back as five models. The models a restore brings back are now noted before the first of them lands.

• Structure cells built together draw the models in the order the session lists them (§25.3). Each cell of a deck rebuilt from a link fell to the first model, its neighbours not being in the deck yet, and the next change to the store moved each one along: the models came back a seat to the left, the first in the last cell.

• A lane’s colour by picker stays inside the card. A select is as wide as its longest option, and a set whose rows carry a long column — insulation’s domains name weaker boundary prominence — pushed the picker a few pixels past the Tracks card’s edge.

• A workspace opened from its address puts the first map where it was saved (§16.9). A published figure or a ?config= link whose deck had its first map moved, hidden or unchained opened with it back in the first cell, on screen and chained: resolving the workspace’s names rebuilt the deck from its other fields and dropped the lead’s. A dropped workspace file was not affected. The store’s Hi-C, micro-C and PCP deck now reads in that order, micro-C second.

• A workspace’s tracks come back under the companions they were drawn under (§16.6). Restoring the tracks wrote the session’s lanes, none yet, over the record of where they were drawn before it was read, and a lane whose map opened before its track had been read was dropped: a deck with MNase under each of three maps opened with every companion bare and MNase on the first map only.

• A table’s scatter has an axes card (§18.13). Its scales, windows and names, the columns’ names (number in Map) as placeholders, so a time course’s axes can say what they are.

• A figure’s window wider than its data is the window drawn (§18.13). The chart’s zoom clamped a window to what was drawn, so a range typed past the data — or a figure opened on another’s ordinate — came out as the data’s own; the axis is now stretched to the window on the side it reaches past. And an end of a window is labelled only when it is a round number, so a box drawn by hand no longer prints its edge, 8.00215, over the tick beside it.

• A table drawn as a chart keeps its mark and legend when its title or type size changes (§18.13). An update in place handed the chart the table’s own style, so its points became a line and a fitted line’s legend moved to the side.

• A figure’s tick labels no longer print over each other (§18.13). Only an axis of names was thinned; a distance axis spelled 300.0 kb, 600.0 kb ran each label into the next once the type size was raised for print.

• A hidden series stays hidden with a figure’s legend off (§18.13). The chart hides a series through its legend’s selection, and a legend switched off carried none, so every series hidden in the settings was drawn again, on screen and in the PNG and PDF.

• A figure’s PNG and PDF leave its hidden series out of the legend (§18.13). On screen a hidden series keeps its greyed entry, the control that brings it back; an export carried that grey name beside no line.

• The circularity check reads each sequence where the file puts it (§8.15). It placed each sequence by ceil(length / bin size), and a level that floors its sequences’ last part-bins has one bin fewer for every sequence that does not end on a bin, so each sequence after the first was read a bin further out for each one before it. On the yeast and M. pneumoniae demo at 2 kb the mitochondrion was read five bins out, its tail and corner from the next sequence, and chromosomix circular failed on the file, its last sequence running past the end of the map. Seven of thirty-two maps tried have levels written that way. Each sequence is now read at the extent the reader gives it.

• A linear chromosome read with few bins is no longer read as circular (§8.15). A map opened at a coarse resolution was measured there, and with a few dozen bins a line’s two ends are too near each other for the junction test: contacts flatten out across a chromosome’s territory, and a yeast chromosome’s telomeres are held together. The mouse progenitors map opened at 2.56 Mb ticked chr9, chr11, chr12, chr15, chr19 and chrY, and the yeast demo .hic opened at 16 kb its chromosome I, at 0.92. A sequence is now measured only where it has fifty bins at the rung read — over thirty-two maps no linear chromosome read with more was ticked — and a smaller circle read coarsely is left undecided, for the reader to tick: the yeast mitochondrion of the yeast and M. pneumoniae demo at its landing rung (43 bins at 2 kb), E. coli opened at 100 kb, and in chromosomix circular at the zoo’s 4 kb, a plasmid under 200 kb.

• A linear chromosome is no longer read as circular on one stray read (§8.15). The junction test took the median of three separations, and where the balancer had dropped an end it was the median of one: chrY of the demo store’s mouse progenitors map, opened at 10 kb and measured at 640 kb, scored 0.41 on a single read pair joining its first bin to the last one kept, beside an end with nothing on its own diagonal, and the map opened under chrY reads as circular. A separation now counts only where the junction has a cell and the diagonal has contacts at both ends, and a score needs two of the three; with fewer the sequence is left undecided, and chromosomix circular leaves its row empty. Over thirty-two maps the rule changes no bacterial chromosome’s or plasmid’s verdict at any rung.

• A tab’s note goes with its file (§5.6). The bar under the tabs said what a tab had found out about its file and stayed until dismissed, so a link that moved a tab from the mouse map to a chicken .hic left chrY reads as circular over a genome with no chrY. A tab’s note now goes when the tab opens another file, goes back to the picker or closes, and waits while another tab is in front; another resolution of the same file keeps it, and the window’s own notes stay.

• Both notebooks render again against this checkout’s chromosomix command (§18.8, §18.10, §23.1). The DBZ figures read the inter-arm table’s log2 score, which has since become its enrichment, a fold, with enrichment after detrend beside it, and E1’s share from a column cooltools’ method now writes as of contacts; and they handed compartments --contacts cis, which a shell reads as the number of contacts to draw the map to, and refuses. Their check on the secondary diagonal is the task’s reading again — each distance’s mean, in log2, from the origin out to the reach — and lands on the table’s two folds to the three decimals they are written to. The validation notebook took one from the peak list’s starts and summits, which are written 0-based now as yapc writes them, and read the BED’s # line as a peak, so no region matched yapc’s.

• A bedMethyl lane names e, g and b as the SAM spec does (§8.20). They were called 4mC, 8oxoG and 4hmC; SAMtags §1.7 has them as 5fU, 5hmU and 5caU (8oxoG is o, and 4mC is ChEBI 21839, with no letter). The lane now reads its names from the table a BAM’s MM tag is read by, so the two never name one code two ways.

• The 1D ruler keeps its end labels whole (§5.8). Each tick label was centred on its tick, so one on a window’s first or last base hung half off the strip: a deck’s tracks cell over IV:1,000,001-1,400,000 read Mb and 1.4, and the browser over a whole sequence bp. The label is nudged back inside, as the heatmap’s axis already nudged its own, and where that brings it against its neighbour the inner one is left out rather than written over.

• The last lane on each edge of a map keeps its whole name (§8.8). A name is written at the reader’s text size across a lane of the height they gave it, and at the default size the 14-pixel peak lanes the yeast demo opens with are five pixels too thin for it: past the last lane that was the edge of the canvas, which cut the chip and the descenders off Pol II peaks and ATAC peaks on screen and in every PNG and PDF saved from the map. The stack now leaves room past its last lane for whatever the name reaches beyond it, and draws a loop’s anchors past that room rather than into the name; a stack whose last lane holds its name, or that writes none, is unchanged.

• A window inside one chromosome of a .hic reads its own blocks, not the chromosome’s (§3.6). An off-diagonal rectangle — a corner, two loci a chromosome apart — unioned its two axes into one span, so it read the whole square between them: six bins by six at a chromosome’s corner was every block of that chromosome, 15 MB at 25 kb on a 4DN map. Each axis now keeps its own window, and the blocks below the diagonal are reached through their transpose as they always were.

• A remote .mcool reads a chromosome in far fewer round trips (§6.1, §12). HDF5 reads the pixel columns a chunk at a time, and each 1 MiB miss was its own request: 63 in a row for chr1 of a 5 GB file. A region read chunk after chunk now fetches ahead, up to 16 MiB, while scattered reads — an open, an index — still fetch only what they ask for: 34 requests, and the picture 15 s after landing where it was 24 s, measured through a slow proxy.

• A first open no longer waits for the HDF5 runtime to load (§6.1). The reader’s worker, which compiles h5wasm the moment it exists, was only made once a file was opened; it is now made while the picker is on screen, and a 1 GB .mcool dropped on a fresh tab lands in 0.3 s where it took 3.2.

• A whole chromosome of a laddered map is first drawn from the rung that is its picture’s grid (§9, §12). A window wider than the picture’s cells was summed out of every pixel of the open rung — chr1 at 25 kb into a 50 kb picture — where the file stores the 50 kb rung. Its first read now comes from the rung that is that grid, the same cells from a quarter of the pixels, balanced at their own resolution, and a zoom still refines to the open rung: on a 1 GB .hic from S3 (4DNFIYUR29KO), chr1 reads in 1.3 s where it took 4.3.

• A whole-genome picture of a .hic reads a fiftieth of what it did (§3.6, §12). The walk across its chromosome pairs read every pair’s matrix record whole — the block index of every resolution — and pulled a megabyte around each kilobyte block. It now reads each record only as far as the rung it draws and each block as exactly its bytes, with four pairs in flight: on the 5 GB 4DN map of mouse granule neurons (4DNFI916JQ1Y), 5.7 MiB where it was 289 MiB.

• Two remote-file refusals stopped saying their own advice twice. The byte-range and transit-compression errors each explained, in the pink diagnosis box, the two things the advice list directly underneath them was about to explain again in different words. The diagnosis keeps what only it knows — which host, which URL, what came back instead of a 206 — and the advice keeps the remedy, which now also names GEO and SRA.

• Nine HTTP header names in the range-source’s refusals were wrapped in backticks, which reach a reader as backticks (§26.4). They are named in quotes, like every other literal the app mentions in prose.

• A resolution the reader added is drawn like one the file stores. It carried a dashed border whether or not it was current, so four added rungs were four outlined chips beside one stored rung with no outline at all, and each reserved fourteen pixels for a × that only appeared under the pointer. Now: no border until it is the rung being read, a dotted one where a stored rung’s is solid, and a × at zero width that the hovered rung grows to hold, pushing the rungs after it along. The × also lost the bordered button box it had been wearing — .btn comes later in the stylesheet than the rule that had always asked for no border.

• The map’s bar names its window twice, not three times. The region view printed the locus as its own heading, again in the summary line directly under it, and a third time in the box at the top right — IV:1,000,001-1,400,000 three times on one bar, all the same string. The summary’s own contribution is the span, which is the one thing the heading does not say, so that is what it prints. It drops the locus only where the heading says exactly the same thing: a genome pair, a contig × contig block and a multi-sequence frame each say something the heading cannot, and are printed whole.

• Both whole-genome gates ask the same question with the same words and the same button. One said compute overview — a word that appeared nowhere else — under a toolbar button reading whole genome, and priced the read in bytes while its sibling priced it in stored pixels. Both now state both figures, and a remote file past the scan limit is warned about on both, in the warning colour rather than the colour of a refusal, with the download offered under it.

• The key stands down on a picture narrower than it is. At three cells across, the lead of a deck — the map every other cell is compared against — had a 14 rem legend over a 175 px plot.

• A workspace brings its circles, origins and added resolutions back in (§3.4, §8.15). Saving one wrote all three and opening it dropped them: the tab reader walked past the fields, so an origin typed on the Chromosomes table, a circle unticked by the reader, a 10 kb rung added to a 4 kb file, and the declarations a store’s published session makes, reached nobody — and the first open then measured its own circles over the author’s.

• A task reads a declared circle as a circle (§8.15). The declarations reached the drawer’s header and not the framing a run was given, so a sequence ticked on the Chromosomes table was measured as a line by every task run from the app — and by a track task run where no map is on screen, which read an origin at the first base as split between the two ends. The run’s framing carries the circles and the origins now, including the one made over the tracks, and a cached result is reused only under the same declarations.

• The inter-MAG network’s per bin pair weighs an edge by the two MAGs’ sizes (§18.8). It fell through to the raw contacts, so choosing it changed nothing in the ranked table; it is now the contacts over the product of the two MAGs’ bin counts. Per coverage is computed as it was — the contacts over the geometric mean of the two MAGs’ intra-MAG contacts — and its hint, which said the product of their totals, now says that.

• Cis and trans per sequence and Reproducibility refuse a run with nothing ticked (§18.2). Both read an empty list as every sequence, so pressing none ran the whole file — the one thing nothing ticked must not become — and the note the cis/trans runner promised for it was never reached. The estimate refuses in the words every other task uses; a run that arrives with an empty list anyway says so before it reads a pixel or mounts a second map, and a ticked name the file has not got is named rather than dropped.

• Roadmap’s tile names WashU when the hub is not there (§24.2, §24.10). A 404 or a page of HTML from VizHub was read as a shipped store not published yet, and the sentence sent a maintainer to run the Stores workflow, which has never written that file. It now says the hub is WashU’s, published on its VizHub, the way the DNA Bacterial Zoo says what publishes it.

• A share link carries the names of maps read from gs:// (§16.10). The map names kept their own copy of the test for which files a recipient can open, written before gs: joined it, so a link sent the map, its lanes and its companions and stripped the name the reader had given each. Every field of a link keyed on a file now asks the one test.

• A bedMethyl opens clipped to 0–100 (§8.20). It opened on the autoscale like any other track — a methylation lane drawn over whatever 12–94 % the window held — and the 0–100 the file reports only filled the limits boxes once the reader had left auto. A bedMethyl loaded now opens on 0–100 under either name it arrives by; a restored one keeps the axis its reader gave it.

• Opening a soft-masked .2bit no longer reads its mask blocks (§8.21). Each record’s header was fetched through to the end of its mask arrays, which the reader then steps over and never reads — chr1’s eight megabytes of offsets on hg38, and tens of megabytes across the genome, on open. A header is read as far as the mask count and no further: one 8 KB read, or for a sequence whose gaps outrun it, a second just long enough for them.

• A folder offers a .barChart, a .bigBarChart and a cytoBand named in the plural (§8.17, §8.22, §20.5). The name router did not know the first two and matched only cytoBand and cytoBandIdeo, so the Files column drew all three dimmed — the yeast demo’s own Yeast_cytobands.txt among them — while the loader read every one.

• The IGV store publishes each genome’s cytoBand (§24.3). IGV names a genome’s karyotype beside its sequence, and the generator dropped it as an ideogram this viewer does not draw, which stopped being true with §8.22. It is now a row filed under cytoband — the two IGV names .bed included — the first track on its genome’s shelf, and an ideogram lane in its session. The generator’s own description lists its five front ends, dnazoo among them, and no longer says the refgene tracks are skipped.

• A model’s bed3d from the Structures card says when it was made (§25.7). The card’s button wrote the model’s name and framing and left the date off, where the drawer’s button and chromosomix write the run’s. It now asks the analysis workspace, which holds the run; a model loaded from a file was not made here and still carries no date.

• The chromosomix command reads a genePred, an interact, a longrange, a GTF and a VCF as the app does (§8.18, §8.19, §23.1). --features asked four of the loader’s sniffers and read everything else as a BED: a genePred, a GTF and a VCF came out as no features at all, an interact as one box over both anchors or a bedpe of the wrong columns, a longrange as a BED4 whose names were its arcs. It now runs the loader’s own sniffers and parsers in its order, and --pairs reads an interact or a longrange as well as a bedpe.

• A plain Run on a map binned from a .pairs is no longer refused (§3.7, §18.3). The analysis worker opens the map for itself, and a contact list opened without the grid the reader chose is refused with choose a bin size — which is what every task pressed on such a map said, P(s) included, because the target a plain Run builds carried the ticked cells and the drawn total but not the binning, nor the orientation curves the import had counted. Run on all maps built its targets elsewhere and carried both, so it worked, which made the failure look like one about the file.

• P(s) by pair orientation has no notches and no gaps (§18.8). All four curves fell by half together every 0.9 of a decade — at 200 bp, 1.6 kb, 12 kb, 98 kb and 730 kb on a Lachancea kluyveri library — because the drawing axis was built on its own at log bins per step over counts kept at 1.05: every twenty-second drawn bin held one counted bin and was divided by the width of two. Every drawn edge is now a counted edge and each point is divided by the width it covers, which is the correction the matrix’s own curve already makes (§18.10); within 60 bp–1 Mb no point on that library stands more than 6 % off its neighbours, where the notches were 50 %. And a bin with no record, which a filtered library has plenty of at short range, broke the line: a run of sparse bins is now pooled into points of at least sixteen records, each over the whole stretch it spans, while a bin that holds sixteen on its own is never widened — so the curves start where the records do, unbroken, and a real spike, −− at 36 bp on the same library, stays one. The detached source a named .pairs was read through is also closed after its pass, where it was left mounted.

• What a task makes of a map is called what the map is called (§16.10). A map renamed on the Contact maps card or its heading kept its file’s name in everything a task made of it: the drawer’s tabs, the all-maps legend (Bsubtilis_dparAB^mapped_PY79^NT9IOH.mcool::10000, for a map called dparAB), the lanes and models a run adds, and a reproducibility run, which also called its own map This map. They take the map’s name now, and the tabs and the all-maps figures follow a later rename. A track or a model was already named by the name it had when a run was made; a task’s form open over the rename now lists it under the new one too.

• A plain Run on a starred companion is that map’s (§18.1). It was filed under the first map — its tab, its lanes and its name were the first map’s — and the Run button never said which map it would measure. In a batch with a companion starred, the first map’s run was lent the companion’s pixels for the region on screen, and came back with the companion’s numbers. The button now says run on ★, naming the starred map in its tooltip.

• Reproducibility is offered as soon as a deck has a second map (§18.1, §18.8). It waited, greyed with open a second map beside this one, over a deck of two, until a batch or a star had made the other map read the tables an analysis needs. A map counts once its file has opened, the first map included when the star is on another; the column is asked again whenever a map of the deck opens, moves to another rung or closes; and a run waits for the other maps’ tables, as run on all maps does, so the first one finds them.

• Reproducibility gives hicrep’s coefficient (§18.8). The diagonals were pooled by the variance of their smoothed counts, which let the few nearest the main one — the largest counts and the highest correlation — carry the answer, and put the SCC a few tenths above hicrep’s and hicreppy’s on the same maps: 0.90 against 0.51 on chicken chr1, G2 against 60 min. They are now weighted as HiCRep weights them, (n + 1)/12 for a diagonal of n positions, over the positions where either map has a contact, from the first diagonal out, on the upper triangle with the diagonal and everything past the furthest stratum set to zero before the smoothing — hicrep 0.2.6’s arithmetic, which the unit tests hold the kernel to at twelve decimals. How far the comparison runs is now part of the answer, as hicrep’s dBPMax is.

• Stop reaches a task in the annotations worker (§18.3). A metaplot, a FRiP or a track correlation ran to its end whatever was pressed, because the worker handed every task there a cancel check that always answered no and the runner never sent it a cancel; only the answer was refused when it came. A task now stops at its next read of a track, and a peak call between its windows and IDR’s rounds. A motif scan, one pass with no read in it, still runs to its end, and the Stop button’s tooltip says which.

• A violin stays inside its figure (§18.13). A violin’s density runs past its sample, and where the ordinate was set — by the task or by typing its bounds — the tail was drawn on below the axis, through the names of the groups; it is cut at the plot’s edge now. And a figure of boxes or violins, which names its series under the axis rather than in a legend, no longer keeps the legend’s strip empty down its right side.

• A task run again draws its new values at once (§18.5). A re-run replaces its own tracks under the same ids, and every lane beside the map, in the 1D browser and on a model went on drawing the previous run’s numbers, under the new run’s name, until a pan or a zoom refetched them — so compartments run again by the other method looked unchanged. The row now carries a revision the run bumps, and each lane asks again when that changes.

• The figure settings’ to is set like the labels around it (§18.13). Under x from, y from and a heatmap’s scale, the word was drawn at the body’s size, larger than every other label in the card.

• A box that takes several sequences accepts a locus written the way the app writes one. Its grammar is comma-separated and a plain split read IV:1,000,001-1,400,000 as four regions, so a locus copied out of the heading above the box came back Expected HYPHEN token missing. splitRegionList knows a thousands comma from a separator — a digit on the left, exactly three on the right — so I, II and 1,2 are still two regions each.

• An analysis form’s locus box is grouped, like every other box that shows a coordinate. It opened with IV:1000001-1400000 directly under a line reading IV:1,000,001-1,400,000 · 1 kb bins: two spellings of one window, in the one place a reader is about to edit the number.

  The box is wide enough for the grouped locus it opens with, with pick on map beside it.

• A figure’s axes no longer print runs of zeros. A P(s) ordinate climbed 0.001, 0.0001, 0.00001, 0.000001, 0.0000001 and the log-log slope beside it reached eight zeros — at which point a reader cannot tell one tick from the next without counting, which is the whole of what an axis is for. The ordinate had no formatter at all. It has one now, and on a log axis every tick is a decade and reads as one; an abscissa in base pairs takes the app’s own span units, so a P(s) reaching a megabase reads 1.00 Mb rather than 1,000,000.

• A run’s clock is twenty-four hour, in every locale. It read computed in 776 ms at 03:29:24 PM — eight characters of which three were punctuation and a word, on the same line as a duration, and two runs an hour apart in the afternoon and the small hours sorted the same. The separators stay the reader’s locale’s; the hour cycle does not, because that is a fact about what the number is for (§26.2).

• An anchor picked off the map now names the bins that were dragged. pick on map wrote the locus in the form made for a clipboard — 1-based inclusive, which is what samtools and bedtools take — and the analysis runners read that parameter with cooler’s grammar, 0-based half-open. So a drag that framed bins 230 to 1042 reached the runner naming bin 231 onwards: one bin along from the stretch the reader had just pointed at, with nothing on screen to say so. A 4C profile is read off its anchor, so the shift moved the peak. The box’s own tooltip no longer claims to take “the same thing the locus boxes take” either (§18.2).

• Hints that told you to empty a dropdown. Leave empty for every sequence in the file sat beside a select whose first option reads every sequence on five tasks: an instruction for a text box that has not existed for some time, naming a gesture the control cannot take. The Model from the map form’s three paragraph-long hints are one line each, with the three weighting cases on the options themselves, and its example no longer names chrIV on a file whose sequences are I…XVI. The heading FROM THE RECORDS — the parser’s word for a .pairs file’s rows — is From the .pairs file, over the .pairs file it asks for.

• The map’s autoscale every track reaches a barChart’s and a junction lane’s axis (§8.17, §8.23). It set auto on the lanes drawn as a profile only, so a barChart with a typed pair kept it beside a map after the button that says every track — while the browser’s own button, the ceiling drag and the ⌘-scroll all moved it. It now asks what they ask: whether the lane has an axis a reader can move.

• A genePred that opened the browser says what it holds. A feature file asked for the genome’s lengths is parsed once and kept, and the row it then loaded into came back through the generic path, reading N features rather than the genePred’s own line. Every format with a sentence of its own now gets it on that road too.

• A lane’s name too long for two lines of the browser’s name column no longer runs out over the lane (§8.8). A name with no break that left both halves inside the column was cut to the width of two lines and drawn on one, so Geuvadis_chrX_GBR…188428.junctions, dropped under its own name, ran across the first arcs of the file it named. It is cut to what two lines hold and broken there, or cut to one line where even that will not break.

• A feature’s card is headed with its name as the file wrote it. The heading was uppercased like a dialog’s category, so a band’s card read XQ28 — a long arm called Q — and a mouse gene’s read as the human one’s symbol. A card headed by a name now keeps its case; one headed by what the feature is (Feature, Splice junction) keeps the dialog’s style.

• The Tracks card’s height box shows three digits. It reserved its spinner’s room at a width where that was most of the box, so a lane of 100 px or more read 10(. It is typed, like the limit boxes beside it, and the arrow keys still step it.

• A BED12 or bigBed of transcripts draws its exons (§8.16). The glyph followed the lane’s kind, and a BED is a segments lane, so a gene set in BED12 came out as one plain box per gene: its blocks and its thick span were read and never drawn. Every feature is now drawn by its own structure, so the same gene draws the same blocks from a GTF, a genePred and a BED12.

• A GTF’s coding span reaches its stop codon (§8.16). The stop codon is a row of its own in Ensembl’s GTFs, outside the last CDS row, and was left out — so every coding gene drew three bases short of its stop, and differently from the same gene in a genePred or BED12. The demo’s genePred is regenerated the same way. A GFF3 transcript written as CDS and UTR rows with no exon rows now draws its exons and introns rather than one box.

• A track’s edge button lights on the press that sets it. Moving a track to another edge of the first map announced the move before it made it, so the row went on showing the old edge — and the session remembered it — until something else changed.

• The sequence bar’s tooltip names the asterisk its placeholder offers. The prose explained a sequence name, coordinates and a gene name, and stopped short of the fourth thing the box takes.

• A sequence track’s length is spelled the way the Genome card spells it. The row read 16 sequences · 12,110,231 bp while the card two columns to its left called the same number 12.11 Mb (§26.2).

• The readout under the pointer names the base. At 47 bases per pixel the browser’s status line read IV:1.27 Mb — two decimals of a megabase, so the number did not change across a fifth of the window — and a lane’s tooltip beside the map said IV:1.18 Mb over 1 kb bins while the matrix tooltip a pixel above said the base. One rule now, on all three.

• A track’s value axis no longer depends on how wide its lane is. The same ATAC track over the same 400 kb read 0 – 111 on a wide lane and 0 – 36.9 in a deck cell, so two cells of one deck — and the two stacks of one map — disagreed about the same file. Autoscale resolves over the values the file states in the window, and a lane narrower than a thousand pixels is sampled as though it were that wide, so the numbers behind two pictures of one window are the same numbers.

• A lane’s label no longer sits on the lane’s own data. Beside a map the block is drawn over the track, and a halo around each glyph was the whole of the protection: on a 16-pixel peak lane ATAC peaks came out with orange bars through every letter, 230 features in view lay across the density block it was describing, and the GC lane’s 0 – 1 ran along the trace it measures. The block now sits on a plate, a name too long for its lane is cut in the middle rather than clipped by it — a track called Distance to IV:1000000 was drawn as Distance to IV:100000 — a lane name is set in the weight the browser sets it in, and a fixed 0 – 1 axis keeps its range beside the name.

• A gene name that is not in the file is never drawn. MSW1 came out as SW1, HEH2 as HE and MUS81 as US81, cut by the lane’s edge and every one of them a plausible yeast symbol. Names are kept inside the lane, and a name may overhang its own feature four times over rather than without limit: a 46-character peak name written under a 3-pixel peak spanned a dozen unlabelled neighbours and read as the label for all of them.

• A gene track stops vanishing into a grey bar when you open a side panel. The collapse to a density profile was measured against one row of the lane, so a stranded gene set that packs into a band per strand was declared undrawable at half the genes it can draw: 230 yeast genes drew as named boxes at one width and as a solid block at another.

• The single-file build has no store drawer, and nothing that opens one (§19, §24.2). It built the drawer as any window does: a button in the header, the backslash and Stores in the palette, each opening catalogues of addresses that a page with no network cannot read, and a ?store= link that went and tried. The drawer is not built there now, and the palette leaves the row out rather than greying it, since no state of that build opens a store.

• An embed’s landing page is Load files alone (§21.2). It offered the store tiles and the row of places to connect, and a frame builds neither the drawer a tile opens nor the Files column a place is connected into: a tile did nothing when pressed, and a folder chosen was connected into a column nobody could see. Its palette greys the same rows — Connect a folder, and the folds of the three columns it does not mount — which were live over nothing.

• The 1D browser’s track-height box reads its lanes, as the map’s does (§8.8). It was built without them, so it went on showing the last number it had applied — 90 over a stack the same box beside the map called 46 — and a press of down made a 46-pixel track taller, which is what the box beside the map had just stopped doing.

• A first map moving on its own stays so across a reload (§16.6). A companion’s chain has always been kept with its look, per file; the first map’s was kept nowhere, and came back closed on every build of the deck — a reload, a restored workspace — so the map the reader had taken off the deck carried every other map with it on its first pan. It is kept beside the first map’s place, and a saved workspace carries it.

• Closing the map keeps the Manual annotations card in the browser it falls back to (§5.8, §8.1). The column that road built held the tracks and left the marks card out, though a browser opened fresh has it: the marks drawn on the map stayed in the session with no card to see, place or remove one by.

• A sequence on the stage can be given its own name back — a dev feature (§27.3). The rename box refused every name of the file’s own, to the sequence that is that original whole as well — which the step allows, and which the refusal’s own words, for that sequence whole and no other, said it did. It asks the step’s rule now, and refuses the name to anything else.

• Review frames the next suggestion once one is answered — a dev feature (§27.6). After Y or N the next best became the one review was on without the map going to it, so the line under the toolbar named a suggestion that was not on screen; → and ← framed theirs, and an answer now does too.

• The stage reads the file’s own sequence, whatever was loaded first — a dev feature (§27.5, §27.8). The evidence of the ends and gaps and the edited FASTA took the first sequence track that was ready, which with a theoretical genome loaded before the assembly’s own FASTA meant telomeres looked for in the wrong set and an edited sequence written as N. Both now choose as the corner dot plot does — the set naming the most of the map’s sequences — through one helper.

• A tracks cell marks both ends of the map’s cell under the pointer (§25.4). It drew one hairline, at the first of the two anchors, where the lanes beside the map mark both.

• A narrow deck cell’s lanes no longer paint over the next cell (§16.5). Three or four across, the first map’s side stacks were wider than its cell and were drawn over the neighbouring cell’s heading and locus box. The map now gives way down to 10rem inside a deck, the rest of the cell scrolls sideways, and the scroll opens with the map in the middle.

• The Export card’s save and copy include a deck’s structure and tracks cells (§16.5). With the first map beside a 3D model and no second map, the card wrote the map alone; it writes the deck’s whole figure whenever any other cell has a picture, as the bar’s own save does.

• The deck’s · N maps lost its bullet whenever the count was written before the first block had filled the summary in front of it; the separator follows the summary now.

• A companion drew the normalisation its own score named (§16.2). A companion reading VC, ICE or the correlation took the normalisation from the first map’s score, so it was labelled one thing and drawn as another; it reads it off its own score now.

• Dropping several local coolers no longer gives a row of empty cells (§16.6). Each opened a live panel and then, a frame later, every one of them was replaced by a vacancy reading this cell held that file and it could not be re-opened — about files the deck still had in hand. The hash can say no more than ~ about a local map, and what a ~ was resolved against was the stored record, re-opened through a filesystem grant; a file that arrived by drag and drop may have no grant — outside Chromium the browser hands over a File rather than a handle, and nothing can ask for one afterwards. A cell the deck is already holding is now the first answer for its own index, and the record answers for the rest.

  Nor when tracks come with them: eight coolers, a GTF and a FASTA dropped on a new tab open eight maps, because a render of a state the view has since moved past no longer touches the deck (§16.11).

• A structure file dropped on an empty window opens as its model (§25.3). A lone bed3d or g3d opened the 1D browser of the genome its beads name, with nothing on it and the model nowhere on screen; the model now opens in its own cell, filling the view, with the empty tracks hidden behind it — show the 1D browser in the deck’s bar brings them back.

• The Structures card’s eye follows the deck (§25.3). A structure cell closed from its heading left its row’s eye lit, and a model dropped on a + or an empty cell left it dark, until the eye itself was pressed.

• A reconstruction no longer destroys the model before it (§25.6). Model from the map landed on the id of its task and removed the row that had it, which is right for boundaries or domains — running insulation again with a wider window means the reader wants the new ones — and wrong for a model: two models of one map are the comparison §25.3 is built for, and a model is not stored anywhere else, so a second run left nothing to compare and no way back. Two runs of one map — two framings of it, or its two methods — are exactly the comparison somebody makes a second model for. A run now takes the next free id in the series and the label carries the same (2), since two rows under one name are two rows nobody can tell apart in the picker or in compare with.

• A mark outside the window is ghosted like the bead it sits on (§25.5). Telomeres, the reader’s own marked places and the genomic ruler’s ticks were drawn at full strength whatever the model was doing, so a window of one chromosome was read against a constellation of solid yellow telomeres nowhere near it — the brightest thing in a picture of somewhere else. The vector export had it right from the start, so the screen and the exported PDF disagreed about the same model.

• A model with a bin the solver could not place is a structure again (§25.2). A solver writes nan in all three coordinate columns for a bin it was given nothing to place — a repeat, a gap in the assembly, a bin nothing mapped to — and the sniffer read the first such row as this file is not a structure and gave up on the whole of it. A 1,683-bead pastis-NB model of a mycoplasma genome has 33 of them and the first is thirty-one rows in, so both files it was written as fell through to the BED family: the .g3d landed on the Structures card by name and then failed with all 1,683 lines failed the “contig, start, end” test that every BED-like format begins with — a refusal naming a format the reader never handed over — and the .bed3d beside it, whose third column really is an integer end, was drawn as a track: a lane of 1,683 boxes whose name is an x coordinate. A bead with no place is now passed over by the sniffer and dropped by the parser, as a bead nowhere always was, and the model opens at the beads that have places. A file where every bead is unplaced says that in those words, rather than in the sentence naming the columns — its columns are fine. A coordinate that is neither a number nor one of the spellings of nowhere (nan, NA, inf, None, ., empty) still says the file is not a structure, which is what keeps a BED6 out.

• A pair the map never counted is the pale end of the ramp, not the dark one (§25.5). Colouring a model by contacts with the pinned bead put every uncounted pair at the top of the scale, so the darkest beads in a virtual 4C were exactly the ones with no contact at all. log10’s clamp folds a zero to 0, which is numpy’s and right on a map whose scale starts there — but the scale here is the map’s transformed range, and a balanced map’s runs from about −3.6 to about 0.

• A ghosted chromosome’s dashes are ghosted too (§25.5). The dashed run of ink across every gap in a chain was flat ink at full opacity, so a model faded almost to nothing still carried a cage of black dashes over it — which read as the one thing being shown. A gap is a fact about a chain, so it fades with the chain, and a gap spanning the edge of the window thins into the ghost as a stick does.

• A marked bead is the colour you gave it, not black (§25.4). Every bead drawn for one of the reader’s own 1D annotations came out black on screen, whatever colour the Manual annotations card showed beside it — and the same mark exported to PDF came out right, because the 2D painter takes a colour as a colour. The sphere’s material asked for vertex colours as well as the instance colour it actually uses; USE_COLOR’s shader multiplies in a color attribute a plain sphere has not got, a missing attribute reads as (0, 0, 0), and the instance colour was multiplied into that zero. (defaultAttributeValues would have supplied a white one, but three defines it only on ShaderMaterial.) Dropping the flag is the whole fix; the colour has always come from the card.

• The 3D card’s colour by no longer reads displacement from the cor…. The option did not fit the column even as a full-width block; the compare with row directly above it names the model, so the option says displacement and the key’s caption with it. A caption that does have to be long — displacement — choose a model to compare with — wraps now instead of being cut mid-word.

• The filter box over the IGV genomes is absent until there is something to narrow. It stood above the red banner of a store that had failed to load, offering a box to type into with nothing behind it.

• A store that has not been published yet says so in the singular and the plural. The message interpolated the store’s name in front of is not generated yet, and half the built-in names are noun phrases of the wrong number — so IGV’s read IGV genome sessions is not generated yet.

• A store that could not be read no longer draws a toolbar over the empty room. A search box, a clear filters and a list/matrix pair stood above the red banner, offering to search nothing, clear nothing and arrange nothing (§8.5).

• The landing page’s privacy note ends where everything above it ends. Its 80-character measure was on the bordered box rather than on the prose inside it, so the last thing on the page stopped two hundred pixels short of the eight store tiles — with an accent bar down its edge making the ragged end unmissable. The sentence keeps its measure.

• The chromosomix command reads a model back in as a structure. A bed3d or text g3d under --features is the structure Spatial tracks and Model versus map read, so a model the shell wrote can be read as tracks in the same batch; it was read as a BED and refused as not a structure.

• The chromosomix command names what it reads from a reference after the file. GC content · PAK.fa and Origin and terminus · PAK.fa, as the app names them after its entry; a reference named with --sequence had no label, and every output read from one said reference.

• An analysis run that was never asked which sequences reads every one of them. Unanswered and none ticked were one value, and on the command line only the first of them exists: chromosomix compartments sample.cool — the README’s own example — refused itself with tick at least one sequence, naming a control a shell has not got. Unanswered is now the whole file, which is the genome-wide compartment call that task exists for, and an empty list is still a reader who pressed none and is still refused.

• chromosomix reconstruct3d writes the model rather than an empty BED (§25.7). A model is an interval set whose rows carry three coordinates each, and the shell wrote every interval set as a BED6 — so a reconstruction run over a batch came out as chrom start end region_1 0 . per bin, which is the assembly handed back with the one thing the run computed dropped for want of a column to put it in, beside a TSV whose every row was blank after the coordinates. Nothing said so: the files were there, the names were right, and the numbers were not in either of them. §25.7 has said since there were models that a model leaves as a bed3d, and the export road a computed row shares with called intervals is the shell’s road too — so --out now writes chrom start end x y z through the drawer’s own writer, the haplotype column where there is one, and the file reads straight back into this app and into g3dtools.

• Closing the share dialog before its link is ready no longer copies the link. The copy that follows the link’s arrival went ahead for a dialog already dismissed, writing over whatever the reader had put on the clipboard since.

• A full circle is drawn in a vector figure. The PDF page flattened an arc of exactly one turn to a path of zero length, so a loop drawn as a ring on screen was missing from the saved figure.

• A view’s heading no longer changes shape as it zooms (§5.4, §26.6). The title bar wrapped or unwrapped whenever a press lengthened or shortened its title, and the summary under it could run to three lines on a pair of loci — so the map jumped a line up or down under a zoom. The heading’s shape is now decided by its width alone (one line, the toolbar under the title, the steps under the box); the title and the summary are one line each, ellipsised with their whole text as a tooltip.

• A label and its dropdown share a line in the panel cards (§26.6). The Map card held score above its select and smooth, transform and colours beside theirs — two shapes for one kind of question. The label column was the cause, not the row: at 6.5rem a dropdown had 67 pixels, which cut adaptive in smooth and left correlation no chance; at 4.6rem, the width of the longest label in those cards, every option fits beside its label.

• The / badge sits in the middle of the box it is in. With no top an absolutely positioned child keeps its static position, which in that flex row is the top of the line, so the badge was four pixels high of centre and wedged three pixels from the border.

• Recentre-to-diagonal is one stroke along the diagonal. It was move-diagonal-2, the same line with an arrowhead on each end: the heads read as drag along here, which is not what the button does, and at 15 px they were most of the ink.

• Seven marks in a card’s row are a block, not six and an orphan. The Map card’s overlays fit one line until the panel had enough in it to want a scrollbar, which takes the fifteen pixels the seventh was living on — and a lone icon under six reads as a different kind of control. Seven or more now sit four across.

• The side columns give way before the picture does. Four columns come to about 1,180 pixels at their own widths, and the centre could be squeezed to nothing: on a 1366-wide laptop with all four open the map was 140 pixels and the locus box 85, showing IV:1,00 of the reader’s own position. The columns now shrink to their minimum widths and the picture keeps a floor of 18rem, which keeps the picture 288 pixels wide at 1366 instead of 140.

  Otherwise a column keeps the width it was given: nothing the centre holds — a summary that grows with a zoom, the Genomes table — narrows it.

• Aesthetics’ and General’s minimum widths are what their own cards need. At 200 pixels the two clip limits read -4.1 and the transform and colours selects cut log10 and default, and the File card left its values about forty pixels. Both are 240 now, and the clip pair has a floor of its own.

• A dialog headed with a file’s name no longer uppercases it. The enlarged 3D cell read YEAST_STRUCTURE over a card, a tab and a Structures row all reading Yeast_structure, and the .pairs binning dialog did the same to the file it names. A heading that is a category is still uppercased; one that is a name keeps the file’s own spelling.

• An empty console no longer offers copy, save and clear. The first two wrote a file with nothing in it and the third forgot nothing. §26.3’s rule cuts both ways: a control with nothing to act on is dimmed.

• A locus box’s placeholder is cut to the box, clause by clause, rather than clipped mid-word. I:1,000-20,000, a sequence, a genome, or a gene wants 458 pixels and the browser’s bar at 1366 is 336 of them, so the box showed I:1,000-20,000, a sequence, a ge — an input clips a placeholder with no ellipsis and reports no overflow, so nothing on screen said a list had been cut, and what was cut was the clause a reader had not already guessed. fitPlaceholder measures the sentence and drops whole clauses off the end until it fits, keeping the example, and puts the offer in full in the box’s tooltip. Re-measured when the box changes size, so widening a panel gives the rest of the sentence back.

• A locus is written with a hyphen everywhere, including the places the audit did not reach. The 3D panel’s four readouts, a read’s row on a lane, a feature card’s span, its exons and its coding stretch, and the read card’s position each spelled the window by hand with an en dash — this app’s mark for a range of values — so a locus wore the punctuation of a quantity. All of them go through formatLocus now, which is the one writer §26.1 names, and the hand-rolled +1 beside each of them is gone with them.

• A copy button you could not see could still be clicked. The console’s per-row copy sits at opacity: 0 until its row is hovered, but opacity hides a button without disarming it — so the last twenty pixels of every resting row were a live target, and a reader dragging to select a line could land on it. Inert while invisible now, which is the rule the tab’s own × already followed.

• Six hints that were two sentences are one. A rule under a track and the reason it is there are one thought, not two; so are a bounded read and the gate on it, and a ⌘C that yields to a text selection. §26.4 now also says which two lines are not that hint and are not held to it — a toggle may add what its off state does, and an empty state teaches the gesture that fills it — because both are facts a control cannot show, and pretending otherwise was going to cost the app eleven useful clauses.

• The File card folds, like every other card in every column. It and its pair in compare mode were the only two headings in the app built by hand rather than by the shared one, so the General column had three cards of which two folded and one did not (§26.6).

• A locus box’s example comes from the file you have open. It said chrI:1,000-20,000 over a yeast genome whose sequences are called I…XVI, and promised a gene whether or not an annotation was loaded to look one up in. The Genomes, Chromosomes, whole-genome and pair boxes have gained the go the other four always had, and the whole-genome view’s placeholder no longer ends mid-word at the clause that says a gene name works.

  It never offers __unbinned__, the first row of a metacool’s contig table, which §7.4 refuses to draw.

  A map’s own box takes its example from the sequence it is showing, and falls back to the view’s noun only where the view’s name carries no coordinates, as a whole genome’s does.

• The landing tables read as one family. The four columns a .metacool guarantees are labelled in the app’s own words rather than as n_contigs and n_bins, with the file’s identifier in the header’s tooltip; the density column is non-zero pixels (proxy), which is what the File card beside it calls the same number; one ticked row is named on the button rather than counted; clear filters greys itself when there is nothing to clear, as clear selection beside it always did; a filter box says filter and a toggle column’s filter is a named control rather than a second bare checkbox meaning something else; and the Cells heading no longer repeats the row count two lines above it.

• The Chromosomes table says chromosome throughout. Its filter box asked for contig names and its empty state named contigs, under a heading — and a breadcrumb, and a File card — reading Chromosomes.

• A heading in a right-aligned table column keeps its beginning. estimated completeness read ed completeness and weighted r read hted r: text-overflow cannot reach the text inside a flex container, so the words were pushed out of the box from the left — and the heading is the only place a MAG metric is named.

• A short table is as tall as its rows. Sixteen chromosomes drew their bordered box to the bottom of the window with two hundred pixels of nothing under the last row, which reads as rows that failed to load.

• The opacity stepper’s up-chevron is back on its own line. In half a side column the ∨ box ∧ row wrapped after the box and left the arrow orphaned underneath — on the Tracks card, in every screenshot.

• The map’s bar keeps its toolbar together. The locus box, go, the four zoom steps and the bookmark are one group, so they drop to the next line in order instead of the zoom steps breaking away under the title — which gave one bar three shapes at three window widths, with §5.4’s “four buttons beside the box” beside nothing.

• A two-letter chromosome crumb is not elided. In an embed’s bar every crumb could shrink, so the shortest gave way first and IV became I… — a different chromosome to a yeast biologist, spelled with an ellipsis wider than the word it replaced. Only the file’s own crumb yields now.

• A tab shows its file’s name. The only tab on an empty strip was cut at Yeast_microC_G2M_1kb… while the crumb below printed the same name whole; the ellipsis was the bold weight of being active crossing a 12 rem cap.

• A value that runs past the File card’s edge shows a scrollbar. uri http://127.0.0.1:5 reads as a value that stopped rather than one that continues; the card has always scrolled, and now it says so. The lengths row is short enough to fit either way — bigWig header, inferred (rounded up) — and the sentence explaining it is said once instead of four times on one screen (§5.8).

• The genome minimap no longer says “on the diagonal” in a session with no map. A link to a file that could not be opened left the map’s view in the store while a browser over the remembered genome was what got mounted, so the card highlighted the first kilobase of IV and described it in contact-map words. Which mode it is now comes from the session rather than from the link.

• The loading screen keeps the file’s name, and shows one meter. Opening Yeast_G2M.scool… became downloading — 1.2 MB of 18.1 MB and then reading pixels — 1,204 of 14,769,558: a sentence with the file in it turning into a lowercase fragment halfway through a minute-long open, in a window that may have two of them going. The phase is a line under the bar, and the spinner goes when the bar arrives instead of turning beside it with both announcing themselves as progress.

• The right-click menu answers the keyboard. Arrow keys walk its rows, Home and End reach the ends, the first row takes focus when it opens and closing hands focus back. The breadcrumb’s table menu closes on Escape, which every other transient surface in the app already did.

• The three read-only status items open their panels from the keyboard. They were plain divs, so the :focus-visible rule written for them could never fire and the request-and-byte breakdown a reader on a metered bucket watches was reachable by pointer only. A screen reader now gets the rows, too.

• Tab reaching the clip values on a map’s key is visible. Focus and hover drew the same dotted hairline in the palest grey the sheet has, over the heatmap; focus takes the accent underline the box itself draws once it opens.

• A structure key of sixteen sequences goes in two columns, instead of a translucent list to be scrolled to reach XVI. The spinner beside a running task is a ring with a track, not a ring with a hole, which at any still frame drew a capital C in front of the sentence.

• The Chromosomes table’s circular tooltip says what a tick does now (§8.15). It promised a map that slides past the sequence’s end and back on at its beginning — removed this release — and that every cis analysis measures separation the short way round. It names ori as the way across the origin, the tasks that read a circle, and the two that do not: chromosight and the observed/expected map.

• The shortcuts dialog’s map gestures are the ones the map answers (§7.2, §8.9, §16.9). Two fingers sideways slide along the diagonal, not the map left and right; a lane is resized by its far edge, not its inner one; a file is taken on any of the map’s four edges, not only below or right of it; and a lane’s grip reaches a tracks cell too. Shift-drag, the map’s own zoom in one dimension, and a drag across a lane, which moves its ceiling, were not listed at all.

• A ladder dropped at its root is said to open on its landing rung (§9). The refusal’s advice read drop the file again and the finest one opens; it opens a third of the way up from the finest, whose reads are the largest the file has.

• A turned companion that does not follow says why (§16.4). Each map opens on a fraction of its own block and rounds that to a whole bin was how bands were cut before the deck cut every companion to the first map’s reach. The refusal says the one way two bands can still disagree: this map’s block does not hold that much.

• A Tracks card row’s grip says where it can be let go (§16.9). Its tooltip offered the map’s bottom or right edge; a row is taken on any edge of any map, a + and an empty cell, the last two opening a tracks cell drawing it.

• The page’s title and the install prompt’s name say nothing of a dev feature (§29.5). Both read (meta)cooler — (multi-genome) cool files, in the browser, with the multi-genome format off by default; the words in brackets are gone, and a test reads both files for them.

• The stores’ toggle and the palette’s Stores name no list to go stale (§24.2). Both named the lab’s data, IGV’s genomes, 4DN and ENCODE while seven stores ship; they say every data store this viewer ships with, and any you connected, and the drawer’s own tiles are the list.

• The tab strip’s rename box is announced as Tab name (§5.6), the reader’s word, where a screen reader was told Session name, a word the strip never shows.

• A public bucket is listed as an address, not as a key (§20.3). The stored-data screen called every bucket scope Bucket keys — access keys for private buckets, so a reader who had connected one public prefix was told a credential was on the disk. A scope with no key is Buckets you connected, named; Bucket keys is there only where part of a key is.

• A console row’s mark names its state in §26.7’s words. finished is done, and the window closed while this was running is interrupted, the status §23.5 gives a run whose window went away.

• A refused bucket listing is plain text (§26.4). The 403 and CORS messages wrapped s3:ListBucket, s3:GetObject, AllowedHeaders and the headers they name in Markdown backticks, which nothing renders in the Files column or the Connect dialog.

• The standalone build calls its folder door connect a folder everywhere (§19, §20). Its landing page did, over the one place it reaches; the Files column’s button and the palette’s command still offered a local or remote folder, with a bucket, a Drive folder and a Dropbox in their hints, in a build with no remote half.

• A variant lane’s right-click menu has the point switch its card has (§8.16). The menu left Point the way each runs off a call set’s lane while the card kept it on, so the two surfaces answered one question two ways.

• A dot plot’s Customise this figure keeps its zoom (§28.2). The column offered the matrix’s Colour card, whose picks changed nothing on the red and blue lines and rebuilt the view at the whole; it holds the Text card alone, and a title set there leaves the view where it was.

• A thirteenth resolution is refused in the dialog that asks for it (§3.4). A file takes twelve added; the thirteenth closed the dialog and added nothing, with nothing said. The dialog says so as it opens, and names the way out — take one off the ladder.

• The File card names the normalisation a .hic is balanced with (§3.6). The reader chose the file’s best vector — SCALE, then KR, then the coverage ones — and showed the choice nowhere, though the section said the info panel names it. A normalisation row does, and says none at this resolution where the rung open has no vector.

• ENCODE’s shard choice stays on screen when every ticked shard failed (§24.2). The rail went with the toolbar, so a reader who ticked a shard the workflow has not written was left a red line and no checkbox to pick another; the sentence takes the rows’ place and the two groups stay beside it.

• A tab on the picker has no read or validation on the status bar (§6.3). The picker starts its reader before a file is chosen, and a tab switched back to handed the bar that worker: both items came back, a counter of nothing and a check that failed when pressed. A tab hands the bar its reader only while a file is open in it.

• Pattern detection’s price, and the chromosight pileup’s, say a band is read (§18.6, §18.8). Both lines priced one dense square per sequence — mouse chr1 at 5 kb was one read and 6,114 MB — after both runs had moved to reading each sequence along its diagonal. Pattern detection’s line counts the strips that read the band and the widest band held at a time, 376 requests and 65 MB there; the pileup’s band reaches as far as its loop set does, which is not known until the run reads the set, so its line says so in words and names no figure rather than the square’s.

• Compartments’ sequences hint is true under every contacts setting (§18.8). It said one correlation over all of them, cis and trans, which is what cis and trans and trans only do — and the default, cis only, is one correlation per sequence. It names both, by the options’ own labels.

• A UCSC hub that cannot be read sends the reader to a connected folder (§24.10, §26.4). The sentence a *.ucsc.edu host adds to the CORS failure ended opening it from a mounted folder, the one place left using the word every other screen gave up for connected (§24.2).

• The palette’s Annotations panel row is live on a metacool (§8.5, §26.6). It stayed greyed there with Absent on a metacool, which carries no annotations — a sentence from the release the cards were gated off a file with a genome layer — beside a column that came up on a metacool with every other file’s cards. The row is under the column’s own gate now, whether the session put any cards in it.

• Two more lines say what the screen shows. The whole-metagenome view’s remote-scan gate set its metacooler network command in backticks, which a hint does not carry (§26.4); it is set as code. The clip boxes’ tooltip read their units off the colourbar, a word the app does not use for the key in the map’s corner.

• The palette’s door survives a half-width window. Below 60 rem the search bar was hidden outright, which left ⌘P — and every command with no button of its own — with nothing on screen to name it. It keeps its badge and loses its sentence.

• 3 problem(s) is 3 problems, and a validation that is running says running.

• The whole metagenome no longer dies with Array buffer allocation failed at bin level (§7.3). The bin-level block was summed into a full-square Float64 and copied to Float32, about 200 MB at its peak against the contig level’s 134 MB for the same raster, so on a tab short of memory the default level failed where the others worked. It now sums the upper triangle and finishes straight into Float32, which is what the other levels cost. And if the tab still cannot allocate it, the view falls back to contig × contig (a cooler’s chromosome × chromosome), starts that read without asking again, and greys out bin × bin with a line saying why.

• A metagenome’s whole-file view is the Whole metagenome. Its crumb, heading, gate and compute button said whole genome, which is a cooler’s view, while the command palette already said Whole metagenome. The genomes table’s button reads whole metagenome → too.

• A table says where the file’s own columns end. A MAG-QC table joined into a metacool brings its own Length and Contigs, so the header read name length contigs bins Length GC-content … — identical numbers under two capitalisations, with no way to tell which one a sort was using. The first joined column now carries a rule down its side and each joined header a tooltip saying so, which is the header’s half of the record card’s joined in with the file.

• A record card no longer says every number twice with nothing to say why. On a metagenome the Genome card read length 7,310,635 bp, then fifteen rows later Length 7,310,635 — and n_contigs 2,153 then Contigs 2,153 — because /genomes guarantees three columns and the file’s creator had joined a MAG-QC table in beside them. Both sets stay, for the reason §5.1 keeps them in the table, with one quiet line between them headed joined in with the file.

• The pair view opens either genome by name. There was one door, labelled open rows genome →, which is not a phrase and did not say which of the two it opened.

Security

• Every web build carries a Content-Security-Policy (§11, §21, §22). The site, each pinned build and the package write one policy into index.html as a <meta>: scripts and styles from the page’s own origin and Google sign-in’s documented sources, no inline script and no style=, connections to https:, the loopback and data:, and no frame-ancestors, so an embed stays frameable. The build fails if its page holds anything the policy would refuse. A script injected through a name in a file would have run with the reader’s S3 key in reach; it would be refused now.

• The single file carries a policy computed over itself (§19). It names the hash of each inline script and stylesheet, and reaches no host: connect-src admits only data: — where the bigWig reader keeps its own wasm — and the blob workers inherit the policy.

• A chart’s tooltip shows a file’s names as text (§18.13). A sequence, sample or series name was written into the tooltip as HTML, which the chart library parses on every hover, so a file with a sequence called <img src=x onerror=…> ran its script when the pointer crossed a Cis/trans or track-correlation cell. Every formatter now escapes what it prints, through one helper — the names, the numbers and a series’ colour, which a workspace file carries as surely as a name.

• A binary file is held to its own size, whatever its counts claim (§10, §12). A .hic, a BAM’s BAI or CSI, a .2bit and a binary g3d with its MessagePack header were read on the strength of the counts and lengths they declare, so a truncated download, a flipped bit or a hostile file sized a typed array, a read or a loop: a sixteen-byte .hic block declaring fifty million records allocated 572 MiB, one negative vector length in a footer read 341 MiB of a 256 MiB file, and a twenty-four-byte .csi declaring a depth near a million would hold the annotations worker for some twenty minutes a query. Each count is now refused — naming the format, the field and the value — unless it is a count, under the format’s own maximum and small enough for the bytes left to hold it, and an offset and length must name bytes inside the file. Over 1,140 seeded corruptions of files the repository’s own writers produce, no reader reads more than four times its file, makes an array past 30 KB or takes a tenth of a second.

• Every inflate stops at a cap (§10, §12). A .hic block, a g3d model, a gzipped or bgzipped text file, a BGZF span, a .pairs stream, a whole file the command line keeps and a share link were each inflated to the end before anything looked at the size. The decompressor is now fed 64 KiB at a time and stopped as soon as its output passes a cap in proportion to what went in — sixty-four times for a .hic or g3d block, where straw allows ten — a BGZF member is held to the format’s own 64 KiB and text to 2^29 bytes, and a line of a plain-gzip .pairs past 64 MiB is refused.