Papyr Write together in Markdown. The server can't read it. Try it GitHub

The command line

papyr reads and edits a room from a terminal or a script, so an agent or a build can use a room as a shared note. It joins the room like a browser does (end to end encrypted: the server never sees the text), does one thing, and leaves. papyr help and papyr help <command> (or papyr <command> -h) are the reference, with examples; this page is the overview. For scripts and AI agents see cli-agents.md, which is what papyr help agents prints. papyr help json prints the objects of --json.

Install

Download the archive of your system from the latest release: papyr-<version>-<rid>.tar.gz (Linux, macOS) or .zip (Windows), with <rid> one of linux-x64, linux-arm64, osx-x64, osx-arm64, win-x64, win-arm64. The release’s SHA256SUMS lists the checksum of each:

sha256sum --check --ignore-missing SHA256SUMS   # macOS: shasum -a 256 --check --ignore-missing SHA256SUMS
tar -xzf papyr-<version>-linux-x64.tar.gz       # Windows: unzip, or Expand-Archive
sudo install papyr-<version>-linux-x64/papyr /usr/local/bin/     # or any directory on your PATH
papyr --version

The binary is one file that carries its .NET runtime. It is not signed: Windows SmartScreen and macOS Gatekeeper may warn on the first start (macOS: xattr -d com.apple.quarantine papyr, or allow it in System Settings, Privacy and Security).

In a public repository each archive also carries a build provenance attestation, a signed statement that the release workflow built it from the tagged commit. A checksum shows that the download is whole, the attestation who built it; check it with the GitHub command line before the first start (a binary built anywhere else has none):

gh attestation verify papyr-<version>-linux-x64.tar.gz -R msallin/papyr

From a clone with the .NET SDK, without installing: git submodule update --init, then dotnet run --project src/Papyr.Cli -- <command>.

The room

A room is a link, and the link holds the room’s secret, so it is never an argument (arguments show in ps and in the shell’s history). Put it in the environment variable PAPYR_ROOM, or in a file only you can read and name it with --room-file <path> (on Unix the command refuses a file others can read: chmod 600).

export PAPYR_ROOM="$(papyr new --server https://papyr.example --expires 1d)"

A room exists once something is written to it; new only makes the link. --expires 1h|1d|1w|30d ends the room after that time, --open <name> makes the link of an open room (its name is its secret). new needs --server or PAPYR_SERVER; the other commands connect to the link’s own server (--server overrides). Servers are wss only, ws to localhost.

The current room

Without --room-file and PAPYR_ROOM, the commands use the current room: one file, papyr/room under $XDG_CONFIG_HOME (else ~/.config; on Windows %APPDATA%), made for you alone (the directory 700, the file 600; refused when others can read it, as --room-file is), holding one link on one line. papyr new --use ... or papyr use < link.txt writes it, papyr use --forget removes it. The order is --room-file, PAPYR_ROOM, the current room; status and link say which. There is one current room and no names for rooms; with several, use --room-file. The file holds the link only, never a password. Like any --room-file it is readable by every process of yours; an expiry bounds how long a forgotten link is worth anything.

Password rooms

A password room’s link holds a random salt, not the secret (https://host/r#p.<salt>, with an expiry p.<salt>.<expiry>): the secret is derived from the link and a password (PBKDF2-HMAC-SHA-256, 600,000 iterations, a few tenths of a second per command). Whoever has the link and not the password is no member, but can test guesses at the password, so make it a long one. Like the link, the password is never an argument: put it in the environment variable PAPYR_PASSWORD, or in a file only you can read and name it with --password-file <path> (the rules of --room-file: chmod 600 on Unix; one trailing line break is not part of the password). A password is 1 to 256 UTF-16 code units after Unicode normalization form C, spaces and case as typed. papyr runs without ICU and cannot normalize, so it refuses a password that is not ASCII (as it refuses such an open room’s name) rather than open another room than the browser does.

export PAPYR_PASSWORD='a long password of your own'
export PAPYR_ROOM="$(papyr new --password --server https://papyr.example --expires 1d)"
echo "first line" | papyr write --create       # starts the room; later commands need no --create
papyr read

new --password takes the password only to check it (not stored, not printed) and prints the link. A wrong password derives another, empty room, and a room that expired or was removed looks the same, so when the server holds nothing for the room every command stops with exit 3 and no room is stored under this password (never “wrong password”). Only replace, append and write with --create start the room under a password: it stands for the browser’s second entry, since a typo would lock the text in another room. --create on a stored room changes nothing; on a link that is not a password room’s it is a usage error.

Commands

Command What it does
new [--password] Prints a link to a new room; --password: to a password room (above).
read Prints the text. --json: {"text", "sha256"}. --sha256: the hash alone.
replace --old <t> --new <t> Replaces the one place where the old text stands (--old-file, --new-file take files; prefer them).
append [--text <t>] Adds at the end (text from standard input without --text). --newline puts one line break before the added text when the room’s text is not empty and does not end with a line break; without it, exactly your text is added.
write [--if-unchanged <sha256>] Sets the whole text from standard input, as the smallest edits (a character diff), so what others type in places that stay is kept.
status [--no-members] Joins and says what the room is and who is in it: kind, server, source of the link, expiry, the text’s characters, bytes, lines and SHA-256, the state of the document (whole, unreadable, pending, outdated, read-only), the members. The others answer a newcomer’s presence within about a second, so status waits after the join until no member has appeared for 1.2 s, and 2 s at most (so it takes 1.2 s to 2 s, within --timeout). --no-members leaves the members out and answers as soon as the join has synced: no presence is sent, there is no wait, the members line is not printed and members is null in --json. A degraded document is an answer (exit 0).
link Prints the link the commands use; on a terminal, where it came from. Never connects; exit 2 when there is none.
use [--forget] Makes a link the current room. On a terminal it asks for the link or the name of an open room, without showing what you type (so it stays out of the shell’s history); a name, r#name or #name takes its server from --server or PAPYR_SERVER, and the stored link always holds the server. Piped input and --room-file need a full link or #name, never a bare word (an empty or wrong variable makes no room). With CI set to anything, it reads standard input and never prompts. --forget removes it (below). new --use does it for a new room.
edit Opens the text in $VISUAL, else $EDITOR, else vi (notepad on Windows), and sends every save to the room, merged with what others typed meanwhile (below).
sync <file> [--from room\|file] Keeps a file of yours and the room’s text in step, both ways, until Ctrl-C; for an editor that reloads silently (below).
image add <file\|->, image get -- <id>, image list Adds an image to the room, fetches one, or lists the room’s images (below).
verify <server URL> [--manifest <file or URL>] Checks that a server serves the published build’s files, unchanged (below).
completion <shell> Prints the completion script for bash, zsh, fish or powershell.
help [command] The overview, or a command’s help with examples (the same as papyr <command> --help).
watch [--once] [--diff] Prints the whole text each time it changes, one line each (\n for a line break, \\ for a backslash; --json: {"text"}). --diff: only what changed (below).

Only watch, edit, status (not with --no-members) and sync show you in the room’s user list; the others join without presence, and their writes still carry --name.

Options of every command: --server, --room-file, --password-file, --timeout <seconds> (default 60: the wait for the join and for the server’s answer), --name (what the others see, default PAPYR_NAME, else papyr; at most 50 characters, longer is refused with exit 2), --json, --raw, --no-color, -h/--help (also -? and /?; zsh needs '-?' quoted), --version. Short forms: -s --server, -r --room-file, -n --name, -j --json, -V --version, -t --text, -d --diff, -o --output; one letter, its value as the next argument or after =, never bundled (-jV is refused). Reserved for later: -q, -p, -f, -v. Edits and image add take --durable to wait until the server has it on disk too (otherwise until it has accepted it), and --create to start a password room.

In PowerShell, bash and zsh a # after a space starts a comment: quote a link or a name ('#notes', 'r#notes'). PowerShell: $env:PAPYR_SERVER = 'https://papyr.example', papyr link | Set-Clipboard.

A value that looks like an option is written --text=--newline (a value that is the name of another option is refused as a mistake); -- ends the options. A link in the file or the variable may have spaces and line breaks around it.

Standard output holds only the result; messages go to standard error. A message is one line, papyr: <what happened>. <the next step>., and quotes nothing another member wrote. Text is UTF-8; a \r in your text becomes \n. Other members’ text is hostile on a terminal: control characters other than newline and tab are written as \u001b and the like unless you pass --raw; --json always escapes them.

On a terminal

Colour is used only where it carries meaning: the papyr: that starts a message (red), watch --diff (additions green, deletions red, hunk headers cyan), the headings of the help (bold) and the hint after new (dim). It is off when the output is not a terminal, when NO_COLOR is set and not empty, when TERM is dumb, and with --no-color; on Windows it is on only under Windows Terminal or a terminal program (WT_SESSION, TERM_PROGRAM). Room text, names and links are never coloured. The bidirectional controls (U+202A to U+202E, U+2066 to U+2069), which reorder what a terminal shows, are escaped like the control characters unless you pass --raw. read ends its output with a line break on a terminal when the text does not, and new says how to keep the link. A Windows console gets UTF-8.

Editing in an editor

papyr edit writes the text to a file papyr-<random>.md in the temporary directory (for you alone) and runs the editor on it ($VISUAL, else $EDITOR, else vi; the value is split on spaces, so code --wait works). While the editor runs, every save is sent to the room: the file is read every half second, and a text that differs from the last one sent and was the same at two reads in a row is a save. A save is merged with what others typed meanwhile, so nothing they typed is overwritten; what they type does not come into your editor, since the file is yours. The session stays joined, so the others see you as present. Nothing is printed while the editor runs. When it ends, a last change of the file is sent too (--durable: that one waits until it is stored).

  • No save differed from the text read: nothing changed., exit 0, the file is deleted.
  • Saves sent and the last confirmed: sent N saves. (sent 1 save.), exit 0, the file is deleted. When the room’s text is not your file’s at the end: ` Others changed the text meanwhile: papyr read.`
  • The last save not confirmed within --timeout, or you interrupted while waiting: the file is kept and named, exit 4. It may or may not be stored.
  • The editor ended with a status other than 0 (or could not be started): no further save is sent, the file is kept and named, exit 2; the message says how many saves were sent before.
  • The session stopped or the document degraded while the editor ran: no further save is sent, edit waits for the editor to end, then fails as the other commands do (exit 3), and the file is kept and named.

Syncing a file

papyr sync <file> keeps a file of yours and the room’s text in step in both directions, until you press Ctrl-C. It is for an editor that saves by itself and reloads a file that changed on disk without asking, such as Obsidian (a note of a vault as a live room) or VS Code with auto save. It joins and shows you in the room while it runs. --timeout bounds the wait for the join and, at the end, for the last save to be stored; it does not end the run.

At the start, with R the room’s text and F the file’s (line endings read as \n, a byte order mark dropped):

The file The room What happens
missing or empty any the file is written with R
not empty empty F is merged into the room
equal to R   nothing
differs from R, both not empty   exit 1, nothing changed: there is no common text to merge from. --from room writes R over the file, --from file writes F to the room (as the smallest edits)

Then every half second: a file text that differs from the last one both sides had and stayed the same at two reads in a row is a save, and is merged into the room with what others typed meanwhile; what others type is written to the file, once per half second however fast they type. Nothing is printed on standard output; on a terminal one line at the start names the file.

  • The file is written as a hidden file beside it, .<name>.papyr (Obsidian does not show it), renamed over the file after one more read of it: when the file is no longer what was read, nothing is written and the next half second decides. A save that lands in the instant between that read and the rename is lost.
  • Line endings become \n: a file with \r\n whose text equals the room’s is not a change, and a file sync writes has \n. It is written as UTF-8 without a byte order mark.
  • The file missing for 5 seconds in a row: exit 1, the file ... is gone.
  • Ctrl-C: the file is read once more and merged if it differs, the last save’s answer is awaited for --timeout at most, then sent N saves, wrote M changes. (sent 1 save, wrote 1 change.) on standard error, exit 0; exit 4 when the last save is not confirmed (it may or may not be stored).
  • The session stopped or the document degraded: the error the other commands give (exit 3).
papyr sync ~/vault/meeting.md

Images

papyr image puts an image into a room and takes it out again. The image is encrypted in this computer before it leaves, as the text is: the server stores a file it cannot read, and sees its size and when it arrived, never its pixels, its file name or its type. Images are off unless the operator turns them on; a server where they are off refuses with exit 3.

  • papyr image add <file> uploads a png, jpeg, gif or webp file (- reads the standard input), then appends its reference, ![<alt>](papyr:<id>), to the room’s text as a line of its own. The upload comes first, so a reference never points at an image the server does not hold. --alt <text> sets the alt text: 1 to 100 characters, none of [, ], \ or a line break; by default the file’s name without its extension, image for the standard input. --no-append uploads without the reference. --if-unchanged <sha256> appends the reference only if the text is still the one with that hash (exit 1 else, and nothing is uploaded, unless the text changed during the upload: then the image is stored, no reference is written, and the message gives it). In a room that is not stored yet the reference goes in first, since that is what stores the room, and it is removed again if the upload is then refused. Plain, add prints the reference; --json prints the object below.
  • papyr image get [--output <file|->] -- <id> writes the image of that id. By default to <id>.<ext> in the current directory, and only for an image; an existing file is never overwritten, and a default name is refused when any <id>.png, .jpg, .gif or .webp exists in the directory (the message names the one found). --output <file> writes the bytes to that file whatever they are, replacing what is there; --output - writes the raw bytes to the standard output (--json cannot go with it). The -- is in every example because an id can begin with -, and then the parser would take it for an option.
  • papyr image list [--raw] prints the references of the room’s text, in text order, one line each: the id, then the alt text (escaped as read escapes text, unless --raw). It reads the text only, so a reference inside a code block is listed too. --json gives the id, the alt text and the line of each.
papyr image add photo.png --alt "the harbour"            # prints ![the harbour](papyr:<id>) and appends it
papyr image list                                          # <id> the harbour
papyr image get --output harbour.png -- "$id"             # writes the image
papyr image add - --json < photo.png                      # {"id":...,"reference":...,...}

The size limit is the server’s: add refuses a larger file before it reads it (exit 1) and says how large an image may be. The command holds the whole image in memory once.

Exit codes are those of “Exit codes” below; a file that is not an image, empty or missing, or an --output folder that does not exist, is a usage error (2). When the image may not be stored yet, the message says to run the command again. When the image is stored and only its reference is not confirmed, the message names the one retry, a papyr append of the reference: running add again would store a second copy.

Checking what a server serves

A page of a sealed room is only as honest as the server that delivers its scripts (privacy). A check inside the page cannot help, since whoever replaces the page replaces the check; papyr verify checks from outside:

papyr verify https://papyr.example                                     # a release: the manifest from GitHub
papyr verify http://localhost:8080 --manifest publish/webcat.json      # any build, with its own manifest

It reads the build from the start page (<meta name="papyr-build" content="1.2.0+<commit>">). The manifest is --manifest (a file, or an https URL), else, for a release, the release’s webcat.json on GitHub (https://github.com/msallin/papyr/releases/download/v<version>/webcat.json); a development build (-dev) or a page that names no build needs --manifest (exit 2). The manifest is in WEBCAT’s format: an object with manifest_schema 1, version and files (each URL path with the SHA-256 of its body in base64url), or a bundle {"manifest", "signatures"}, whose manifest is read. Its signatures are not checked: the trust is in where you took the file from. default_csp, extra_csp and wasm are read past: the CSP is not compared.

Every path of the manifest is asked for as a browser asks (Accept-Encoding: br, gzip, the body decoded), four at a time, and its SHA-256 compared. A path differs when its body has another hash or does not decode, its status is neither 200 nor 404, or the answer has a Location or Refresh header; redirects are not followed. A 404 serves no code: such a path (a page a setting turns off) is listed as not served, never as a difference. A build the page names that is not the manifest’s version (with or without its +<commit>) is a difference too. Plain, verify prints https://papyr.example serves build 1.2.0+<commit> exactly as published (N paths), with the paths not served and, when there is one, the latest release; or each path that differs, <path> <how>, then the message. Exit 0 the same, 1 a difference (do not trust the pages that server serves), 2 usage or no manifest (a manifest that is not one included), 3 the server failed (5xx), 4 network or timeout (--timeout bounds the whole check).

What it proves, and what not:

  • What was served to the command line, at that moment. A server can serve the original to it and another page to a browser (by address, time or headers); a pass says nothing of what your browser got.
  • That the build is exactly as published, not that it is the latest (it names the latest release when github.com says).
  • The default manifest also comes over TLS, from github.com: against a TLS-intercepting proxy, take the manifest from elsewhere (--manifest) or check it with gh attestation verify.
  • Headers other than Location and Refresh are not compared. A CSP header can only tighten a page’s own; every page’s CSP has worker-src 'none' (no service worker), and the PlantUML frame pins the CDN’s scripts by hash in plantuml/frame.html, which the manifest covers.

Completion

source <(papyr completion bash)                               # in ~/.bashrc
papyr completion zsh > "${fpath[1]}/_papyr"                   # or source it
papyr completion fish > ~/.config/fish/completions/papyr.fish
papyr completion powershell | Out-String | Invoke-Expression   # in $PROFILE

The scripts complete the command, then its options (and the help topics, and the shells for completion).

Windows and PowerShell

  • Set the room: $env:PAPYR_ROOM = (papyr new --expires 1d --server https://papyr.example); or papyr new --use ... once.
  • Output encoding: PowerShell decodes a program’s output with [Console]::OutputEncoding, which is the OEM code page on Windows PowerShell 5.1 and some installs of PowerShell 7, so papyr read > note.md can mangle non-ASCII text. Run [Console]::OutputEncoding = [Text.Encoding]::UTF8 once per session (or in the profile), and prefer --json in scripts. papyr itself writes UTF-8 to a console.
  • Get-Content note.md | papyr write adds \r\n per line: a \r becomes \n as documented, and the last line gains a line break; use Get-Content -Raw note.md | papyr write.
  • The mode check of --room-file and the current room is Unix only; on Windows %APPDATA% is yours by its ACL.
  • edit uses notepad when neither VISUAL nor EDITOR is set; $env:EDITOR = 'code --wait' works.
  • Colour is used under Windows Terminal and VS Code (WT_SESSION, TERM_PROGRAM), not in the legacy console.

Watching what changed

watch --diff prints, for each change, what changed against the text before it, and nothing for the text the room holds when the command starts. --once stops after the first change (exit 4 when none comes within --timeout). Changes that follow each other before the command looks again are one change. Text that others type stays hostile: it is escaped as everywhere else (--raw writes it as it is).

Plain: a unified diff of lines with one line of context. A hunk starts with @@ -a,b +c,d @@ (the line where it starts and the count of lines in the old text, then in the new one; both counts are always written, a count of 0 starts at the line before), then its lines: ` ` a context line, - a deleted one, + an added one. A line that ends the text without a line break is followed by the line \ No newline at end of file. There are no --- and +++ lines. An empty line ends each change, after its last hunk: a context line is never empty, it starts with a space, so the empty line is the delimiter.

@@ -1,3 +1,3 @@ by Alice
 first
-second
+SECOND
 third

@@ -3,1 +3,2 @@ by Bob, Alice
 third
+fourth
\ No newline at end of file

--json: first, when --once is not given, {"sha256":"<hex>"} (the hash of the text at the start; read --sha256 gives the same), then one object per change, on one line: {"edits":[{"at":1,"delete":2,"insert":"xy","by":["Alice"]}],"sha256":"<hex of the new text>"}. at and delete count Unicode code points of the previous text; insert is the text that takes the place of the delete code points from at. The edits are in ascending order and do not overlap: applying them from the last to the first to the previous text gives the new one, whose SHA-256 is sha256. The edits are the smallest the library finds (a diff of code points, write’s own); a change of more than 1000 code points inserted and deleted can be one edit that replaces everything between the start and the end that did not change.

Who: every part of the text that is inserted carries the Yjs client that made it, and each client writes a name for itself in the room’s authors entry. by (in the JSON, on each edit that inserts) and the words after the second @@ (in the plain diff, for the lines the hunk adds, joined with , ) name the authors of the inserted text, each once, as those entries say, or unknown when the author has none. A deletion has no author (Yjs does not record who deleted): an edit that only deletes has no by, a hunk that only deletes has nothing after the @@. The names are what each member chose for itself and nothing verifies them: anyone can write any name, also another member’s. They are escaped like the text (in the plain diff a line break in a name is written \n).

JSON

--json makes a command write one object per result, on one line (watch: one per change, JSON Lines), UTF-8, control characters and U+2028, U+2029 escaped. Offsets and counts are in code points, hashes the lowercase hex SHA-256 of the UTF-8 bytes, times RFC 3339 in UTC with Z. A key listed here is always present; an absent value is null.

Command Object
new {"link": string, "expires": time or null, "kind": "sealed" or "open" or "password"}
read {"text": string, "sha256": string}
replace, append, write {"status": "applied" or "not-found" or "ambiguous" or "changed", "stored": bool, "matches": int, "sha256": string or null}: sha256 is the text as this member holds it after the call (after a refused edit, the text of now; null when the session stopped)
watch {"text": string} per change
watch --diff first (not with --once) {"sha256": string}, then per change {"edits": [{"at": int, "delete": int, "insert": string, "by": [string]}], "sha256": string}
status {"room": {"kind", "server": string or null, "name": string or null, "expires": time or null, "source": "option" or "environment" or "current"}, "text": {"characters": int, "bytes": int, "lines": int, "sha256": string} or null, "document": [string], "members": [{"name": string, "colour": string, "self": bool}] or null}: members is null with --no-members; text is null when the document is degraded; document lists what is wrong (unreadable, pending, outdated, read-only), [] for a whole one
link {"link": string, "source": string, "kind": "open" or "sealed" or "password", "server": string or null}
image add {"id": string, "reference": string, "bytes": int, "type": string, "upload": "stored" or "exists", "status": string or null, "stored": bool or null, "sha256": string}: status and stored are the reference’s edit (null with --no-append), sha256 the text as it is after the call; printed before the message when the text changed under --if-unchanged (exit 1), as an edit’s object is
image get {"id": string, "bytes": int, "type": string or null, "file": string}: type is the image’s (null for a file that is not one, given with --output); file is the name written
image list {"images": [{"id": string, "alt": string, "line": int}]}: line counts from 1
verify {"server": string, "build": string or null, "manifest": string, "version": string, "sameVersion": bool, "result": "same" or "differs" or "refused", "paths": int, "differ": [{"path": string, "reason": "hash" or "status" or "location" or "refresh" or "encoding" or "refused", "status": int}], "notServed": [string], "latest": string or null}: build is what the start page names, version the manifest’s; latest only for the default manifest, null when github.com does not say
--version {"version": string}
an error on standard error, {"error": {"code": "unmet" or "usage" or "refused" or "network", "message": string, "exit": int, "closeStatus": int or null}}; the result on standard output is what it was (an edit’s object is still printed before the message)

Before 1.0 the objects and the exit codes may still break, whenever a better design wins; a break is marked feat!: in the change log. From 1.0 the rule is: a key is added, never removed, renamed or retyped; the set of values a key can take grows, never shrinks; a consumer ignores keys it does not know; an exit code never changes meaning.

Guards, retries and waiting

replace, append and write take --if-unchanged <sha256>, the hash read --sha256 (or an edit’s sha256) gave: the edit is made only if the text is still that one, else the status is changed, exit 1, nothing changed. A chain of edits guards each on the sha256 the one before returned, with no read between them. A guard that is not 64 hexadecimal digits is a usage error.

An edit that exits 4 was sent but not confirmed, so it may be stored. The message names the retry: the same command with --if-unchanged <the hash before the edit>; exit 0 then means it is stored now, exit 1 that it was there already (or someone else wrote: read to tell). A link whose expiry has passed is refused before any connection, exit 3.

watch --settle <s> reports a burst of typing as one change: only once the text has stayed the same for s seconds (0 to 3600), as one change from the text before the burst to the last one; by names everyone who inserted during it. watch --once --diff --json --settle 2 --timeout 600 waits up to ten minutes for a human to start and then to stop. A burst that ends where it began reports nothing.

Exit codes

Code Meaning
0 Done (an edit: the server accepted it).
1 The condition did not hold: the old text is nowhere or in several places, or the text is no longer the one --if-unchanged names (for image add, after the upload: the image is stored). Nothing else changed. A too large image, or an image get does not find in the room, is 1 too.
2 Usage: the arguments, the link, a file.
3 An unexpected error (the command stopped; read the room before you retry). An image the server refuses, or that does not open under the room’s key, is 3 too (see Images). The server refused or stopped the session (an expired or removed room, and the like), or the document cannot be used: it is not the room’s whole text (a stored part that does not open, updates waiting for others, a newer format) or the room is full; a password room with nothing stored under the password (without --create). The reason is on standard error.
4 The network, or the timeout. For an edit: it was made but not confirmed, so it may not be stored. For image add: the upload or the reference may not be stored (the message says which, and the retry).