Skip to content
ArcadiaDesign

Can you find out why the build fails on the new runner?

Hazel

Found it. The install step reads an old lockfile, so every one package resolves to the wrong version.

  • bun.lock names 1.2.0
  • the manifest asks for 1.3.0
    • only the new runner sees it
  1. Delete the cached lockfile
  2. Install again:

A pin changes only with the lock that matches it.

The whole log is at https://example.com/runs/runner-seven/install and the runner's notes (github.com) say why. @Juniper can review the fix.

TSX

The text people and agents write, drawn with a small set of marks: **strong**, *emphasis*, ~~struck~~ and code between backticks; a fenced code block; a quote of one level; lists of bullets and numbers, one level deep; and an https:// or http:// address as a link, bare or with words: [the notes](https://example.com/notes) draws the words as the link and the host it leads to after them. Asterisks only, and only at a word's edge: an underscore never formats, so snake_case stays whole, and an asterisk inside a word is text, so 2*3*4 stays as typed. A line break typed is a line break drawn. The source stays plain text, so it reads the same where it is not drawn.

Everything takes the text style of what holds it: a bubble's Headline, a card's Body or a row's Caption. Strong is that style's bold, an icon in it stroked to match; code in a sentence is the system's monospace on the code surface at the sentence's size, never larger than Body; a code block is Body in the monospace; and the first and last blocks add no margin. Ranges are spans of the source the product has already understood, each with the node to draw in its place: a mention as a MentionPill. A range is never read for marks, though a mark may run across it; inside code it is text.

Examples

Marks

Each mark as written and as drawn. A backslash before a mark makes it text.

WrittenDrawn**strong**

strong

*emphasis*

emphasis

~~struck~~

struck

`code`

code

**strong with *emphasis* inside**

strong with emphasis inside

\*a backslash keeps a mark\*

*a backslash keeps a mark*

snake_case and __init__ stay whole

snake_case and __init__ stay whole

2*3*4 and file*name*s stay as typed

2*3*4 and file*name*s stay as typed

A line and the next

A line
and the next

- a bullet - another, long enough to wrap onto a second line under its own text - one level in
  • a bullet
  • another, long enough to wrap onto a second line under its own text
    • one level in
1. first 2. second
  1. first
  2. second
9. ninth 10. tenth
  1. ninth
  2. tenth
> A quote, one level

A quote, one level

```ts const answer = 42; ```

Lists

A list keeps its markers inside the text's edge, so nothing of it stands in a bubble's or a card's padding: a bullet or a number stands where a paragraph starts, and its item's lines start after the marker and a step of space.

Hazel

Two things changed on the runner:

  • the cache moved to a disk of its own
  • the install step reads the lock first, so a stale one fails at once instead of half way through
    • the old runner never did
  1. Point the pipeline at the new runner
  2. Copy the cache
  3. Run the install twice

Numbers end on one line, so 9 and 10 keep their points together.

Words written as a link are the link, and the host it leads to follows them in the quietest ink, in lower case and without www.: words never hide where a link leads, even when they name another site.

WrittenDrawnRead [the release notes](https://github.com/acme/app/releases) before you update.

Read the release notes (github.com) before you update.

[google.com](https://evil.example/sign-in)

google.com (evil.example)

[the [beta] notes](https://www.example.com/beta)

the [beta] notes (example.com)

[https://example.com](https://example.org/elsewhere)[open](javascript:alert(1))

[open](javascript:alert(1))

[the notes](https://example.com/notes

Words that are an address of their own give way to the address, drawn as a bare link.

The rest of Markdown

Everything else has one plain fallback. An image loads nothing: its alt, then its address; a table stays as typed.

WrittenDrawn## A heading

A heading

![a chart](https://example.com/chart.png)| check | runs | |-------|-----:| | lint | 12 | | test | 340 |
<b>bold</b> <script>alert(1)</script>

<b>bold</b> <script>alert(1)</script>

---

---

- [ ] a task box
  • [ ] a task box
A footnote[^1] [^1]: the note

A footnote[^1]

[^1]: the note

Addresses

Only http and https link, by the parsed address, and a link shows its host in ASCII, so a look-alike shows as what it is; a long one fades and copies whole.

WrittenDrawnhttps://example.comhttp://example.org/a?b=1(see https://example.com/docs/setup).The steps are in the guide (https://example.com/docs/runners/setup-the-new-runner) and in the log.https://example.com/reports/builds/runner-seven/logs/install-step/attempt-three?view=full&lines=all#first-failurehttps://exаmple.com/sign-inhttps://[email protected]/

A bracket that opens a link goes to a new line with it, never staying behind, and the one that closes it follows it.

Mentions

A range drawn as a MentionPill, inside a mark and beside one. Inside code the same range is text.

Thanks @Juniper, the fix is in. Ask @Juniper, not @Juniper, about the cache.

References

A range's node may be a function: it gets the words written there and returns what stands in their place, a Reference to a card here.

CREW-12 Move the build to the new runner waits on CREW-9, which is in. #CREW-40 was archived.

A key picked from the list after # shows its title, a key typed alone shows the key, and one that names nothing stays plain words.

A mark at the end

end puts a small mark after the last word of the last line, a step of space on, in the line's own pair: a read mark here, on a paragraph and on a list.

Merged. The runner picks it up on the next push.

Two steps left:

  • copy the cache
  • point the pipeline at it

It moves to a new line only with that word, and a copy of the text leaves it out.

A card's text

Several paragraphs, a list and code in a card's body, at the card's own text style.

Move the build to the new runner

The old runner stops taking jobs once this lands.

Done when

  • the install step passes twice in a row
  • the cache is warm on the new runner
  • nobody reruns a job by hand
  1. Point the pipeline at the new runner
  2. Copy the cache:

Questions go to @Juniper.

Preview

formattedPreview gives the first line a source draws, as plain text with its marks taken off: for a list row, a notification or a link card.

On a server

parseFormatted is the reading under the part, with no React or StyleX: a server imports it alone to learn what is code before it calls a mention a mention.

TSX

The marks are the semantic elements (strong, em, del, code, pre, blockquote, ul, ol and a), so a screen reader names a list, its items and a quote. A heading in the source is strong text, never a heading of the page.

A bare link's name is its whole address, the same as its title; what it shows is hidden from assistive technology so nothing is read twice. A labelled link's name is its words and its title the whole address, and the host after it is read as the text it is. Every link opens in a new tab with no opener and sends no referrer. A mention inside a link's words is its text, so a link holds nothing that acts. A code block that scrolls sideways takes focus, so its arrow keys scroll it.

Each paragraph, list and quote takes its direction from its own text, and a link and a code block are always left to right, so an address keeps its order in a right-to-left message. A range is the product's node: a MentionPill brings its own name and, with onClick, its button.

FormattedText

sourcerequired
string
The text as written: plain text, read for a small set of Markdown marks. Nothing else decides its look.
ranges
readonly FormattedTextRange[]
Spans of the source the product has already understood (start and length in UTF-16 units), each drawn as its node. A range is never read for marks, though a mark may run across it; inside code it is text. One that overlaps another, runs outside the source or crosses a line is dropped.
end
ReactNode
A small mark that ends the last line (a read mark, a time): after the last word, --space-1 on, in the text's own style at its regular weight, so an icon in it takes the line's pair. It goes to a new line only with that word, never alone, and a copy leaves it out. After a closing block of code it stands under the block, at its end.
rootStyle
RootStyle
Typed StyleX override: where the text sits (layout only).

Rest props go to <div> props.