Several people, one Word file, at the same time.

• A colleague's text appears as they type it, coloured by author, with a named caret where they are. If they are on another page, the header says “editing, page 41” and one click takes you there.
• Nothing is lost or doubled. Two people editing the same word end up with the same text — both edits in place, in the same order for everyone.
• Track changes with five people. Every insertion and deletion carries its author; the Review pane is live for everyone; the numbers of changes never collide; the saved file opens in Word with the same authors.
• Undo is yours. ⌘Z takes back your edit even if a colleague typed ten letters after it — their letters stay.
• Identity comes from your system. No accounts of its own: the name over the caret is the name your portal returned.

Avatars of the people in the file and a “typing” indicator in the header are landing now (September 2026). Live carets, author colours and off-screen presence are in the server images already.

The server is not a web app with a database of documents. It is a set of small processes around the same engine that powers the desktop apps:

• A cabin is one person's session: a page in their browser plus their own engine process on the server, which holds the document in memory and applies commands — insert, delete, split a paragraph, insert under track changes, undo.
• The manager — one per document — takes every edit accepted from its author, gives it a number (the one order everyone follows) and hands it to the other cabins. It is the only source of truth about order.
• Transfer. If your edit was composed against an older state — while it travelled, someone else's edit was applied — the engine rebases it through theirs: shifts the position, cuts it around their insertions, and on a tie (“both at the same spot”) applies the rule of the canon: the lower number goes left. Your colleague's engine does the mirror image. The result is identical for everyone.
• Fingerprint. Every engine computes a hash of the document. Five people, five equal hashes — that is the measure of convergence, not a feeling. Every 15 seconds the manager compares them; a cabin that disagrees at the same applied numbers is reloaded from the holder's state. That reload is insurance, not the mechanism: the target we test against is zero reloads.
• The holder — the person who opened the file first — writes the file back to your storage. Others are neighbours; someone who joins later opens the already re-saved file and catches up with the canon.
• Big documents (thousands of pages) are edited through a page window: a colleague's letter recomputes the touched block, not the whole book.

you ── your engine ──┐
                     ├── manager: numbers every edit, relays it, checks hashes every 15 s
colleague ── engine ─┘
                     └── holder writes the .docx back to your storage (or Layers)

The engine is the same one that opens a file in 0.11 s on the desktop. Sequential commands, a receipt for each (revision, hash before and after, what changed), and refusals arrive before the change — the document, its history and the file stay untouched.

1. Inside your own system — two URLs

The editors run as a container next to your portal. They have no users, no passwords and no database: your people stay logged in to your system, the editor asks your API “who am I” (--auth-url) and “give me file id” (--attach-url), and writes the edit back through the same API. If you have a personal cabinet and files, both URLs already exist. Two people opening the same file land in the same document and edit together; a version precondition (X-Layers-Attachment-Version) means nobody's save is silently overwritten — a conflict is refused with the reason.

docker run -d --name sumdoc-webhost --restart unless-stopped -p 127.0.0.1:8090:8090 \
  -v /srv/sumdoc-cabins:/data/cabins hissih/sumdoc-webhost:latest \
  --base-path /sumdoc --max-cabins 12 --idle-min 20 \
  --auth-url   'https://your-system/v1/me' \
  --attach-url 'https://your-system/v1/attachments/{id}/content'

Document systems that speak WOPI (the protocol Nextcloud, ownCloud and SharePoint use to hand a file to an editor and take it back) can use the second door of the same image: --wopi-hosts, an allow-list, off by default — discovery, CheckFileInfo, GetFile, PutFile, locks and proof keys. Honest note: we exercise it against our own WOPI host; a measured walk-through against a real Nextcloud is on the list, not on the shelf, so we do not list Nextcloud as supported yet. The full host contract, the comparison with WOPI and ONLYOFFICE, a sample host and a doctor that checks your host ship inside the image (HOST-CONTRACT.md, INTEGRATION-30MIN.md). Details on the developers page.

2. Layers — our own workspace, the editors already inside

If you do not have a system to embed into, Layers is a self-hosted team workspace where documents and spreadsheets open in SumDoc and SumSheet — the very same server images, wired to Layers' own “who am I” and “file by id”. Drop a .docx into a page, share the page with a colleague, and you are both in the document. Public image on Docker Hub, one Compose file: the Layers node.

See it running without installing anything: app.layers.md is our own Layers node. Sign in (free), create a page, drop a .docx or .xlsx, open it, then open the same page from a second browser — that is the server on this page, live.

• Five people in one document, 119 scenarios, all green in under four minutes — typing in the same paragraph and in different ones; Enter and paragraph merges under someone else's typing; multi-paragraph paste; deleting a passage four people are typing into; bold/italic/style under concurrent input; composition input (diacritics, CJK); insertions and deletions under track changes; undo and redo; the join-later case against the re-saved file.
• A colleague's edit reaches you in ~50 ms on the same node; the Review pane on the neighbour's side refreshes in ≤50 ms.
• Ten soak runs in a row under load — the same scenarios with the machine busy — 10 of 10 converged.
• Change numbers per person live in their own band (2²⁰ numbers each), so tracked insertions from different people never collide when the file is opened in Word.
• Spreadsheets (SumSheet): cells, colleagues' edits kept out of your undo stack, undo with four people typing — 31 checks in the gate.

Every guarantee above is bought with a test that fails when the guarantee is removed. The acceptance harness starts five real browsers against a real server; the scenarios are in the repository, not in a slide.