v0.2.0

Added

• A table cell can show you its Markdown. A cell renders while you type in it, so a bold word is bold and its asterisks are hidden, and until now there was no way to see what was underneath. With a cell open, Cmd+Alt+E shows that cell's Markdown, and the same keys put it back. It is the one cell you are in: every other cell stays rendered, so you can read the markers on the value you are working on without turning a wide table into a wall of pipes. The </> button on the table's toolbar still shows the whole table.

• Editing a table cell gives you the same two menus as editing anywhere else. Selecting inside a cell opens the toolbar you already know, now with Edit Markdown and Copy ref on it, and right-clicking a cell opens Sheaf's own menu instead of your system's cut-and-paste one. Both act on the cell rather than on the document around it: Edit Markdown shows that one cell's source, and Copy ref names the row as the file will hold it. Neither offers Turn into, because a cell holds one line and a heading marker written into one is a character of the value. A csv or tsv cell holds data rather than Markdown, so it still gets your system's menu.

• Sheaf can say which build it is. Sheaf: About shows the version, the commit it was built from and the editor it is running in, with a button to copy that one line for a bug report; a build made from a modified copy of the source says so. And when a newer build is installed while your window is open, Sheaf offers you a Reload Window button once, rather than leaving you looking at the old one with nothing to say so. The browser tab carries the same line in the footer of its folder page, since there is no Extensions pane out there to consult.

• An emoji written by name is drawn as the emoji. :warning: shows as ⚠️ and :rocket: as 🚀, where before both stayed on the screen as the name and its colons. About 1,900 names are known, the same set the large code-hosting sites draw, so a README reads the same in Sheaf as it does there, :+1: and :-1: included. A name that is not one of them stays as typed, which is what those sites do with it too, so a time like 10:30:45 is left alone. The file keeps the colons and the name exactly as written, and putting the caret on the line shows the name again.

• The heading list can keep its header with the list folded away. Its header says Contents and is also the control: press it to fold the list and press it again to bring it back, with the text column staying exactly where it is either way. sheaf.tableOfContents now takes shown, collapsed or hidden, and the true and false it took before still mean shown and hidden, so nothing changes for anyone who set one.

• A document's front matter can be one line, or nothing at all. The YAML block at the top of a file is metadata rather than text, and a long one pushed the first heading off the screen of anybody who opened the file to read it. It now draws as a single strip naming the block and the document's title, which is the new default, and Sheaf: Hide Front Matter takes even that away: the text begins where it would in a file that never had any. Nothing leaves the file, a find still matches inside it, and putting the caret in the block opens it whatever the setting says. sheaf.frontMatter sets the default, and Show, Collapse and Hide Front Matter are in the Command Palette.

• A .txt opens in Sheaf when you ask for it. Right-click one and choose Open in Sheaf, or use Reopen Editor With. Double-clicking still opens the plain text editor, so a log or a fixture behaves as it always did, and this is for the notes people keep in a .txt that are Markdown in everything but the name. It is read exactly as a .md is, and nothing is written to the file unless you edit it. Files with a .txt name are listed in a browser tab too.

• Footnotes are drawn as numbered notes. A [^label] in a sentence shows as a small raised number, numbered in the order notes are first referred to, as on GitHub, and hovering it shows the note. The note itself, [^label]: text, shows with the same number in front of it in smaller, quieter text, where you wrote it. Cmd-click (Ctrl-click on Windows and Linux) goes from a number to its note and back. A marker with no note stays as typed, and the file keeps your labels exactly as written.

• A view is something you can find, rather than something you have to know how to write. A view shows a table filtered, sorted, trimmed to some columns, or as a board of cards, and until now the only way to make one was to type its query. Now: Create view on a table's own menu writes one below the table; View of a table in the slash menu writes one reading the table above the caret; Show as board above a view turns it into a board and back, asking which column to group by; and a table with no name offers Name this table, which is what a view reads it by. Everything they write is text you could have typed, and one undo takes any of it back.

• Mermaid diagrams are drawn in place. A fenced block with the language mermaid shows as its diagram, as it does on GitHub: flowcharts, sequence and state diagrams, gantt and pie charts, timelines and the rest. Edit Markdown shows the source, a diagram that does not parse shows its source with Mermaid's message, and diagrams follow a light or dark theme. Mermaid ships inside the extension and loads only when a document has a diagram, so it works offline and a document without one opens no slower.

• Comments are notes you can read and put aside. A <!-- ... --> on its own lines is drawn as a box labelled Comment, in the style of the callouts, with a chevron that shuts it to its first line. Which comments you have collapsed is remembered for the folder, and never written into the file. A comment written inside a sentence keeps the styling it had, and <!-- --> inside a code block is still code.

• Sheaf: Toggle Comments and the setting sheaf.comments put every comment away, leaving a small marker where each one is. Click a marker to read that comment.

• Open in Sheaf is on the right-click menu of the editor's tab and of the text itself, as well as the Explorer's. After turning Sheaf off as the default, or dropping one file to raw text, getting a document back is wherever you happen to right-click.

Fixed

• A code block's panel is a clean rectangle again. It had a small square bitten out of each of its four corners, clearly visible on a light theme. The panel is painted per line and reaches a little way past the text on both sides, and the two lines the fences sit on were clipping their own strip back to the text, so the block's top and bottom edges came up short.

• Text under a table no longer jumps as the table scrolls into view. Until a table is drawn the editor places everything below it from an estimate of its height, and the estimate was wrong twice over: it used a line height from a stylesheet that had changed underneath it, and it divided the writing column for a table that is drawn in the whole pane. The two errors pulled opposite ways, so each looked small and fixing either alone made it worse.

• Widening one table column no longer narrows all the others. Dragging a column's divider made it a claim on a fixed budget: the table's total was held at the pane's width, so every pixel the dragged column gained came out of the rest, and getting two columns right meant dragging back and forth. Measured, a 120px drag gained that column 120px and cost the two beside it 50px and 70px. Your first drag now fixes every column where it is, so the one you are dragging moves alone and the table grows by what you added, scrolling sideways in its frame once it is wider than the pane. A table you have never dragged still sizes itself and still follows the pane, and Reset column widths hands a set one back.

• Scrolled to the end of a wide table, there is a margin after the last column. It ran flush into the edge of the pane, so nothing told you whether that was the last column or whether there was more past the edge; the only way to find out was that the table stopped moving. There is now a gap after it the same width as the one the first column has at rest. At rest nothing changes: the table still reaches the pane's right edge with no empty gutter beside it.

• The block handle no longer sits on top of a wide table's cells. Scroll a table sideways and its columns pass into the left margin, which is where the drag grip lives, so the grip ended up drawn squarely over whichever column header had arrived under it and read as a stray glyph inside the data. It now steps up to the strip above the header row while the content is under it, where there are no cells at any scroll position, and drops back beside the header the moment you scroll the table home. A table that fits the writing column is untouched.

• A board card moves with the pointer while you drag it. It used to sit exactly where it was, faded, while the destination column took a highlight, and then appear in its new place on release, so the gesture read as a click that teleported something. The card now comes with you, a dashed outline shows where it will land between the two cards you are between, and the place it came from holds its size so nothing shifts under your hand. Carrying a card past the edge of a board too wide for its pane scrolls the board, which is the only way to reach a column that is off the screen. Letting go outside every column returns the card and writes nothing, as Escape already did.

• Open front matter has a chevron that folds it back. Collapsed, the block drew as one strip with a chevron on it; open, there was nothing to press, so the only way back was the right-click menu or the Command Palette — which nobody looks in for a control they just used. The chevron is now there in both states, in the same place, pointing down when the block is open and right when it is folded. If the caret was in the metadata when you fold it, it moves to the start of your text, so you are never left typing into something that is no longer drawn. Hidden keeps no chevron: that state reserves no space on purpose, and a control in it would be the space back.

• A column's menu chevron has room beside its name instead of sitting on top of it. It lives in the header cell's right padding, which is empty where a name is left-aligned and is exactly where a right-aligned one ends — and a column of numbers is right-aligned by default, so in the tables people actually keep it landed against the last character and read as a stray glyph in the column's name: "Flares⌄". Every header now holds that space whether the chevron is showing or not, so no name moves when you bring a pointer near it.

• Clicking the paragraph under a diagram puts the caret on that paragraph. It put the caret at the end of the document instead, so a person clicked where they wanted to type and started typing somewhere else. A diagram is drawn a moment after the editor has measured the space it sits in, and the editor was keeping the smaller number it took before the drawing: everything below the diagram was laid out short, and a click below it resolved past the end. Arrowing down was wrong the same way. A one-pixel window resize used to fix it for as long as the document stayed open.

• Code in a fenced block is coloured, and not only its strings and numbers. A keyword, a function name, a property and a class name were every one of them drawn in the same grey as the prose around them, four units apart on a single channel, which is not a difference anybody can see. So a block of code read as a block of monospaced text with two colours in it. All of them have their own colour now, from a palette that is Sheaf's own rather than borrowed from the icons in the editor's suggestion list, and it follows a light or a dark theme.

• A table's command bar can be pressed however you reach it. The buttons above a table did nothing unless the pointer arrived from over the table itself. Coming down to them from the line above, the click landed on that line instead, so the bar looked present and dead. They take the pointer from any direction now. A click on the blank line above a table still reaches the line, which is what kept the bar from swallowing them before.

• A document opened in a browser tab has Sheaf's icon. The tab carried the browser's blank-page mark, and the page asked for an icon on every single load and was told there was none.

• Editing inside a bare web address no longer shows its angle brackets. Typing a space in <https://example.com>, or breaking the line inside it, put the < and > back on the screen, so an address you were part way through correcting looked like it had gained two characters. Half an address is not an address, so it stops being drawn as a link and the brackets go with it.

• Turning a callout into a heading, a list, a quote or plain text no longer leaves [!NOTE] on the page. A callout's first line is drawn as its label, with the marker itself off the screen, so a block command applied to it handed you your words plus the callout's type as literal characters, sometimes with a bullet in front of them. The label line now goes with the callout, the way a code fence's backticks go when you unwrap a code block. A callout with a title of its own keeps that title as the line's text, because the title is the part of that line that was yours.

• The toolbar acts on the table cell you are editing, instead of somewhere else in the document. A button pressed while a cell was open formatted whatever you had last selected outside the table, which in a long document could be anywhere. The word in the cell was left alone, the cell closed, and nothing said so, so there was no reason to go and look for the change. Bold, Italic, Strikethrough, Highlight, Inline code, Link, Clear formatting, Undo and Redo now apply to the cell, and Undo takes back what you did in the cell rather than stepping the document's history. The commands that make a block, the three lists, Quote, Code block, Text style and Insert, are drawn unavailable while a cell is open, because a cell holds a line of text and there is nowhere in it for a heading or a list to go. In a CSV or TSV cell, which holds data rather than Markdown, the whole set is unavailable.

• A numbered sub-list starts at 1 again. Pressing Tab to put a step's detail under it carried on the outer list's numbering, so a set of steps read 1, 2, then 3, 4 indented under step 2, and the next step said 5. The sub-list now counts on its own and the step after it takes the number the sub-list stopped using, so you get 1, 2, then 1, 2, then 3. Shift+Tab puts an item back into the outer list's count the same way. A list you deliberately started at another number still starts there.

• A letter you have just typed is kept when something writes the file from a copy it read a moment earlier. Sheaf already protected typing that had not reached disk yet. One moment later, once your own auto-save had carried the letter to the file, the arriving version was taken whole and the letter went, leaving a notice and an Undo as the only way back. Which of the two happened came down to where a timer you cannot see happened to fall. Now both changes are kept: the write is measured against the text it was actually made from, so a change to another line stays a change to another line. A write that arrives long enough afterwards is still taken at its word, because by then it is as likely to mean the deletion, and that case still tells you what it took.

• Typing in a cell of a large table no longer slows down as the table grows. Every keystroke was measuring and estimating the whole table rather than the cell it changed, so a table of forty thousand cells took about a quarter of a second to show each letter. It is now about a tenth of that, and a table of four to ten thousand cells types exactly as fast as a small one. Nothing about the column widths changed: a column still takes the room its content needs when you finish editing a cell.

• In a browser tab, linking to another document offers the folder's documents again. Typing a link's ( paused for a second and a half and then offered only the headings of the document you were in, so linking to another file meant knowing and typing its path. The folder's documents are offered straight away, the same list the tab's own index page shows, and it is read fresh each time so a file you created a moment ago is in it.

• In a browser tab, the line-numbers button turns them off again. The first press turned line numbers on and every press after it did nothing, so the only way back was to reload the tab. It now toggles, as it does in the editor. The folder's own setting is the value a tab opens with, and changing it in the tab stays in the tab: nothing is written to settings your project has checked in.

• Open raw Markdown shows the file as it really is, blank lines included. A blank line that only separates two blocks is drawn as a gap rather than an empty line of text, which is right while you are reading the document and wrong the moment you ask to see its Markdown: the separators stayed squashed, so the view meant to show you what is on disk was the one view misreporting it.

• The Up arrow no longer skips a line. In any document with headings, Up stepped straight over the blank line above each one, so a quarter of the lines could not be reached going up and pressing Up then Down did not put you back. Up and Down now visit the same lines in both directions.

• One press of Left at the start of a heading no longer destroys it. A heading's # and a quote's > are not drawn, so there were two cursor positions in the same place on screen: on the words, and in front of the marker. Left put you in front of it and nothing appeared to move, and the next letter you typed went before the #, so the heading silently stopped being a heading. Left at the start of a line's words now goes to the end of the line above, which is where it was always meant to go, Right onto such a line lands on its words, and Up and Down land on the words too.

• Paging down and back up returns you to where you were. Twelve presses of Page Down and twelve of Page Up left the paragraph you started on eight lines off the top of the screen, so looking ahead in a long document and coming back cost you your place. A page is now a count of lines, which is what the text editor beside your document does, rather than a distance the cursor rounds to the nearest line: it can only round one way going down and another coming up, and the difference adds up. Both the document and the cursor come back. A screen holding a table or several headings now pages by a little more than one screenful, and a screen of tightly spaced blocks by a little less, which is the trade that buys you your place back.

• Line numbers stay on. Turning them on lasted until you closed the document, so every document opened without them and anyone who works with them on turned them back on every time. The answer is now kept for you rather than for a file: the next document has them, so does the next project, and so does the editor after a reload. It is the sheaf.lineNumbers setting, so you can set it without opening a document, and nothing about it is written into your files.

• Headings line up with the text under them. Every heading sat six pixels to the left of the paragraphs below it, which is visible the moment a heading has body text under it.

• A wrapped line never begins with a space. Where a line wrapped just after a hidden marker, the closing ~~ of a strikethrough or the _ of an italic, the space before the next word was pushed onto the new line and indented it by a character.

• A highlight inside a table cell draws as a highlight. ==like this== in a cell stayed as its equals signs while every other mark in a cell drew. Arithmetic in a cell is left alone: a == b is not a highlight, and neither is a longer run of equals signs.

• Keyboard shortcuts in menus are readable. The ⌘, ⌥ and ⇧ glyphs were drawn in a font that has none of them, so each fell back separately and sat high beside the letter next to it.

• The right-click menu leads with what you reach for. Edit Markdown, Copy ref and Send to terminal come first, then Turn into, then the formatting.

• A write that lands in the same moment Sheaf saves no longer loses one side of it. With something else writing the file at the instant Sheaf's auto-save ran, whichever write reached the disk second won and nothing said so. Sometimes that took a letter you had just typed, while the editor went on showing it, so the screen and the file disagreed until you typed again. Sometimes it took the change the other program had just made, which is worse, because nothing was watching for that. Sheaf now checks that the file holds what it wrote, and puts the two changes together when it does not.

• A write landing in the instant after Sheaf saves is treated as somebody else's, which is what it is. When something wrote the file just as Sheaf's own auto-save finished, Sheaf took the change for the echo of its own write. A letter you had typed a moment earlier could then leave the screen with nothing said about it. Sheaf now tells you what the write took and Undo brings it back, as it already did for a write that arrived at any other moment.

• Typing a data table out by hand no longer rearranges your document. Partway through the second row, the grid appeared over a block that had not been finished and took the next keystrokes as cell entries: a line moved, a blank line went, a stray letter was left at the end of the file, and the closing fence landed above the block it was meant to close. Every fenced block now waits for the fence that closes it before it is drawn as anything, which is also how Markdown itself reads an opening fence, so a csv, tsv or view block, display maths and a diagram all stay as the lines you typed until the block is finished.

• A picture you write by hand appears. Typing ![alt](path) left the line showing nothing at all: not the picture, and not the text you had typed either. Closing and reopening the file was the only way to see it. This also brings back the frame that marks a picture whose file is not there yet, which the same fault had been hiding.

• A block you are dragging survives a change written to the file underneath it. An agent or a formatter writing the file mid-drag left the block undimmed with the drop line still showing, and the release then moved nothing at all, with no message and nothing to undo. The block being carried is now found again in the document as the change left it, and the drop line keeps aiming at the same place in the document rather than the same point on the screen.

• A change written to your file while you are typing in it is kept, instead of disappearing. An agent, a formatter or a branch change writing the file used to have its work taken straight back out, silently, because the text your editor was holding was read before that change existed. The two are now put together a line at a time: your letters where you typed them, and their change where they made it. A write that touched several places keeps every one of them, and settling the line you happen to be typing in costs nothing anywhere else in the file. Where you and the write changed the same line, yours stands, and if that leaves nothing at all of what was written, Sheaf says so.

• A paragraph an agent deletes next to the line you are typing in stays deleted. A write made from the file a moment ago is behind on that one line, and with nothing unchanged between the two, the deletion and your line were read as one change, which then disagreed with your typing and was dropped with it. The paragraph came back, in the file and on screen, and the agent was left believing it had removed something that is still there. A line and the same line typed further into are now recognised as one line, so a change beside your work is kept and only the stale copy of your own line is dropped.

• A document whose file was written while you were typing still saves, and says nothing alarming. VS Code refuses to write a document whose file has moved since it last read it, and it re-reads a file only into a document with nothing unsaved in it, so a write from an agent or a branch change left every save failing from then on: the tab stayed unsaved with auto-save on, closing it asked, and a notice said your changes would be lost. By that point Sheaf has read the write and put it into your document, so there is nothing to choose between the two: the file is written, and the unsaved mark goes away.

• The slash menu, and the list of files and headings offered while you type a link, follow the line you opened them on when the document scrolls, and close when that line leaves the screen. They used to stay at the height they opened at, and once the editor redrew they sat at the top of the window over the toolbar, hiding the buttons, while the line was somewhere out of sight above. Picking something then wrote into a line you could not see.

• Typing a table out by hand writes the two lines you typed, instead of taking the line away mid-word. A table is a table as soon as its delimiter row parses, so typing | - | - | became a grid at | - | -, and the space and the pipe still to come landed under the table as a line of their own. The grid now waits until you leave the line, and the file gets what you typed.

• A table's header row stays at the very top of the pane while its rows scroll past, instead of holding partway down with rows still showing above it. A header row with nothing in it now scrolls away with its table rather than riding down over the rows as a blank band, and a held header has an edge under it.

• A heading has space above it again. The spacing the stylesheet defined for headings had never reached the page: CodeMirror's own rules outrank it, so every heading in every document was drawn with none. Sections separate properly now, with the space above a heading rather than below it, so a heading stays attached to what it introduces.

• A document with a table no longer runs off the right edge of a phone screen. The text column was being widened past the screen by the table's touch-sized command bar, which then never folded, because the room it measures is the column it had just widened. The column is the width of the window now, and anything wider than it scrolls inside its own frame.

Changed

• The right-click menu on a table draws an icon beside every command. It was twenty-four rows of plain text, and the same command reached from the table's own chevron menu had an icon while the one reached by right-clicking did not. They are the same glyphs, at the same size, so the two menus read as one thing. Copy ref and Send to terminal get glyphs of their own rather than being the two blanks at the top.

• A click on a link opens it, and a right-click edits it. A plain click used to put the caret in a link's words and nothing else, so following one meant knowing to hold Cmd — which people who had not read the docs did not. Now a click opens it, everywhere a link is drawn: in your text, in a table cell whether or not you are editing it, in a view, and on a board's cards. Cmd-click still works. A drag that begins on a link still selects, because a click is a press and a release with nothing moving in between, so selecting a paragraph that contains a link is unchanged. A picture is not a link: clicking one does nothing, as it always did, and Cmd-click still opens the image file.

• Right-click a link and its panel opens, with the words in one field and the address in the other. Changing a link's words was the one link action the right-click menu never offered. Copying the address and removing the link are on that panel too, so nothing was lost with the menu; a right-click anywhere that is not a link opens the menu exactly as before.

• The toolbar, the menus and the rest of Sheaf's own controls use your editor's UI font. They were drawn in Sheaf's document font stack, so on a platform where the two differ the toolbar read as a web page bolted into the editor rather than part of it. Their sizes are unchanged: four named steps that match what was there before, in place of the fifteen different values that had accumulated, two of them half a pixel apart from each other.

• A wide table uses the pane instead of stopping mid-column with an empty gutter beside it. Prose wants a measure; a table wants room. A table too wide for the writing column now starts where your text starts, in line with the paragraph above it, and runs to the right edge of the pane, and scrolling it sideways carries its columns across the full width. The fade at its edge has gone with it: a table that reaches the edge, with a scrollbar under it, says there is more without hiding a column behind a gradient. A table that fits the writing column sits in the column with your prose exactly as before, and one inside a quote keeps the quote's own column.

• A link in a table cell opens on a plain click. It needed Cmd or Ctrl, so a table whose first column is ten document links was a list of things that look clickable and are not. Prose keeps the modifier because a click there is where typing goes; a cell you are not editing has no caret to place, so a click on a link in one has nothing else to mean. Cmd-click still works, a click anywhere else in the cell still selects the cell, and a drag that starts on a link still selects a range. The same on a board's cards. Open a cell for editing and it is text again, with the prose rule.

• Pasting a path to another document writes a link carrying that document's title. Copy a document's path, put the caret where the link should go, paste, and you get [Launch plan](docs/launch-plan.md) instead of the path on its own. The title is the target's first heading, or its file name when it has none, and the address is written relative to the document you are in. A relative path, an absolute one and a file: URL all work, as long as the file is in your workspace and is Markdown; anything else pastes as the text it is, because a path outside the workspace would give you a link that works on your machine and is broken for everyone who clones the repository.

• Asking for a link asks for the address, instead of writing [text](url) into your document. Cmd+K, the Link button and Link in the right-click menu used to put raw brackets and the word url on the screen in an editor whose whole point is that they are not there, and anybody who clicked away instead of typing left [text](url) in the file as a link to nowhere. A small panel now opens over the words, with the words in one field and the address in the other, and nothing reaches your file until you press Enter. Esc, or a click somewhere else, and the file is byte-for-byte as it was. With words selected the caret starts in the address field, since the words are already there; with nothing selected it starts in the words. A selection over several paragraphs still becomes one link per paragraph, each keeping its own words, all to the one address you typed once. The caret lands after the link and one Undo takes the whole thing back.

• Cmd+K inside a link edits it instead of destroying it. It used to take the link off, so the one shortcut people reach for to change a link was the shortcut that removed it. Now it opens the link's panel with the caret in the address field, both fields filled, and the file untouched until you press Enter. The Link button on the selection toolbar does the same and reads Edit link. Removal has a key of its own: Cmd+Shift+K takes the link off the one you are in, or off every link in a selection, in one undo step. And Cmd+Enter opens the link you are in, the same way Cmd-click does, so a relative path to another document opens in Sheaf and an address with a scheme goes to your browser.

• Every line is a line, and the document stops moving while you work in it. A blank line between two blocks used to be drawn a third of the height of a line of text. It grew to full height the moment the caret reached it and shrank again when the caret left, so pressing Return, arrowing down a document or clicking in a gap shifted everything below by two thirds of a line. Two blank lines in a row looked different depending on which one you were nearest, and there was no way to look at a gap and know how much of it was your file. Now a blank line is exactly as tall as a line of text, wherever it is and wherever the caret is: one blank line is one line of space, two are twice that, and nothing below the caret moves as you arrow through a document. Documents are taller than they were, which is what the file says.

• Headings keep the same air above them at every level, and one size does for all code. The space above a heading was a proportion of the heading's own size, so an h1 got 32px and an h6 got 21px: air that ran out exactly where a heading was hardest to spot. Every level now gets the same space, and a heading sits closer to the text under it than to the section above it. The heading sizes are GitHub's own, so a document looks here the way it will look once it is pushed, which moves four of them: h1 up a little, h4 to body size with its weight carrying the rank, and h5 and h6 down slightly. Code had drifted to four different sizes below body text, so the same snippet read smaller written inline than in a fenced block; all of it is one size now. A table's text is body size, as a table's cells hold the same prose the paragraphs do.

• A picture aligned left or right lets the text run up its side. That is what the markup means everywhere else, and it is the markup Sheaf's own alignment buttons write — so a document laid out here read one way here and another way once it was published. Each picture took a band across the page with a large empty area beside it, and the paragraph meant to sit alongside started underneath. Now the words wrap around it, as they do on GitHub. Centre is unchanged: a centred picture still has a band of its own.

• A picture sized by height is drawn at that height. An image written with a height and no width — valid HTML, and what you get pasting an <img> in from elsewhere — was drawn across the whole column instead. A thumbnail meant to be 90 pixels tall filled the page. The height was in your file the whole time and survived every edit; it just never reached the picture.

• A code block sits in a frame instead of wearing a background. The grey panel behind a fenced block was exactly the width of the lines in it, so the first character all but touched its left edge and a long line touched the right. The panel now reaches past the code on both sides, and the code stays in the same column as the paragraph above it, so the two still read as one document. Select a whole line inside a block and the selection fills the frame rather than stopping where the characters stop. A block inside a quote or a list keeps its panel inside that block's own indent.

• Press Enter on a list item and the caret is already where your words go. It used to sit hard against the new bullet, a little left of the column the item above starts its text on, so the first letter you typed jumped right as it arrived and the list looked ragged for exactly as long as you were looking at it. Numbered items never had it and bullets, stars and task items all did. Now every kind of item puts the caret on the same stop, at every level of nesting.

• The words on a diagram's arrows no longer sit on a grey patch. A label on a flowchart's arrow was drawn on a colour of the diagram library's choosing rather than on your page, so in a dark theme each one read as a highlighted block, and in a light theme as a faint one. Labels now take the background they are actually drawn on, whatever theme you are using, including the ones that are neither light nor dark.

• Clicking under a comment, an equation or a diagram puts the caret where you clicked. Each of those is drawn as one object in place of its lines, and each was spaced with a margin the editor could not measure, so everything below it was a little further down than the editor believed. Click the line under one and the caret landed on a different line. A table had the same fault and was fixed before; these three had it too and nobody had asked. A comment's tinted box is now a touch taller, which is the one visible difference.

• A browser tab says when an outside write took what you just typed, and offers it back. Open a document in a browser tab, type, and let something else write the same file from a copy it read a moment earlier: the write wins, which is what any editor does with a file that changed underneath it, and your sentence was gone with nothing said and nothing to reach for. Now a notice appears at the bottom of the page quoting what was taken, with an Undo button, and your own Undo key does the same thing whether you press the button or not. A write that leaves your typing alone, or that changes a part of the file you never touched, is still an ordinary change and says nothing at all. This is what a VS Code window has always done; the tab was the half that did not.

• Backspace on a callout's label takes the callout, not half its marker. Taking one character of [!NOTE] leaves something that is not a marker at all, so the label came back as brackets and one keystroke left the wreckage of a callout on the page. Backspace, Delete and delete-by-word now all do what they already do at the left edge of a heading: the callout becomes an ordinary quote and its words stay, with one Undo to bring it back. A titled callout keeps its title, since that is the part you typed.

• Typing on a callout's label writes in the callout instead of taking it apart. A callout's first line is drawn as its label, so the caret has as many places to sit along it as the marker has characters and every one of them looks the same. A letter typed at any of them landed inside [!NOTE], which stopped it being a marker, so the label vanished and the brackets appeared as text: one keystroke and the thing you were writing in was gone from the page. Enter cut the marker in half and Shift+Enter wrote a backslash into it. All three now put what you typed at the top of the callout's body and leave the marker exactly as you wrote it. With the Markdown showing, the marker is the text you are editing and is typed into as written.

• Turning a callout into a list no longer writes [!NOTE] into your document. A callout's first line carries its type marker and nothing you wrote, and it is drawn as the type's label rather than as text. Pressing Bullet list, Numbered list, Task list or Quote on it used to leave the marker behind as literal characters, so - [!NOTE] appeared where the label had been. Every block command now takes that line with the callout, and a titled callout keeps its title, since the title is the part you typed.

• A list reads as a list rather than as a paragraph with markers in it. Items written without blank lines between them sat exactly one line apart, the same as two wrapped lines of one paragraph, so six task items ran together as a block of text with boxes in it. Each item now has a little air above it, the amount GitHub gives a list on a rendered page. An item whose text runs onto a second line gets that air once, at its top, rather than between its own lines; the first item of a list adds nothing, since the blank line above the list already separates it from what came before; and a list you wrote with blank lines between its items keeps them, so it still reads looser than one you wrote without.

• A quote holds still when you put the caret on it. Its words used to slide 14px to the right as the caret arrived and slide back as it left, because the > appeared beside them while the space they sit at had already been set aside for it. The words stay where they are now, at every level of nesting. With Reveal syntax on the caret's line on, a quote is the one marker not shown on that line, which is the cost of the words not moving. A callout's own > [!NOTE] line is the exception and still shows in full, because that line is the marker rather than words in front of one, and it is the line you edit to change a callout's type.

• Emptying a whole column keeps its name. Selecting a column by its header and pressing Delete used to clear the name along with the values, leaving a column with no name. A column's name is how the rest of the document refers to it, so a view that shows, sorts or groups by that column stopped working, and said so on the view rather than at the table you were looking at: you emptied a column, watched it empty correctly, and a board further down quietly stopped grouping. The values now go and the name stays. To clear the name as well, select the header cell on its own and press Delete.

• Lists and quotes sit where they should. A list item's marker now hangs to the left of its words, and every item starts its text at the same place: a bullet, a 1., a 10. and a task checkbox all line up, so a numbered list no longer shuffles sideways as it passes item 9. An item that runs onto a second line comes back underneath its own words instead of returning to the margin under its marker, which is what had made the number read as the first word of the sentence. Nesting steps in evenly, one step per level, and the step is read from the shape of the list rather than from the number of spaces in the file, so two spaces, four spaces and a tab all mean the same depth. A quote steps in once per level and draws a rule for each, so a quote inside a quote is visibly deeper where before every depth looked identical; a quoted table or view lines up with the quoted words around it, and a callout keeps its coloured rule. A task item draws its checkbox and no longer a bullet beside it. The lengths are the ones GitHub uses for rendered Markdown, so a document looks here the way it will look once it is pushed.

• Home goes to the start of your text, by the same rule on every kind of line. It used to land wherever the drawn line happened to begin, which was a different place on a heading, a quote and a bullet, and on a quote it stopped between the > and the space after it, so Home and then Backspace took the marker away. It now goes to the first character of the line's own text, past the #, the > or the bullet, which is the one place where what you type next joins the line instead of breaking it. On a line showing its Markdown it goes to the very start, because that is what showing the Markdown is for, and on a wrapped line it goes to the start of the line you are looking at.

• Selecting cells in a table no longer colours the row numbers and column headers. They stay as they are, so they never look like links; the selected cells show the selection.

• A code block no longer shows its ``` fences. The block is drawn as a panel of code, and the language you wrote after the opening fence is a small label at the top right of it. The fences are still in the file; Edit Markdown on the block shows them, which is how you change the language. A block indented by four spaces is unchanged.

• Copy ref is on the toolbar that floats over a selection, beside Edit Markdown, and its key is now Cmd+Shift+C (Ctrl+Shift+C). Selecting the lines and handing them to an agent is one gesture and then one click, instead of a chord with three modifiers or a trip through the right-click menu. The old Cmd+Shift+Alt+R still works.

• The toolbar's view buttons pack with the rest once the bar folds onto a second row, rather than sitting alone at the far right of it.

• A blank line that only separates two blocks is drawn as the gap it is, instead of as an empty line of text. Documents read tighter: a heading and the table under it sit about 18 px closer. The blank line is still in the file, untouched, and a caret on one gives it back its height.