Files
notescraft/specs/collaboration/research/collaboration-landscape.md
Marcos Paulo d7617f4351
ci / ci (macos-latest) (push) Has been cancelled
ci / ci (ubuntu-latest) (push) Has been cancelled
ci / ci (windows-latest) (push) Has been cancelled
feat: server revisions in the Versions tab, collaboration research
- engine: ServerClient file_history, file_revision and restore; commands server.history, server.revision, server.restore (bound vault only, 5 MiB cap, no token in any answer)
- ui-egui: the Versions tab lists the server's revisions under the local snapshots with Compare (diff against the note) and a two-click Restore
- specs: collaboration research (browsed, 866 lines, 211 sources) and its ranked next features added to the collaboration task list

Verified with cargo xtask ci (fmt, clippy -D warnings, workspace tests, layers, tree, i18n).

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-20 12:07:43 -03:00

71 KiB

Collaboration and publishing landscape — NotesCraft

Research date: 2026-10-20. Companion to specs/collaboration/spec.md (server-ordered OT on plain Markdown, accounts with many vaults, roles owner/editor/viewer, invites) and specs/capture-and-publish/spec.md (planned publish + share links). Sibling research: specs/mobile-and-sync/research/sync-landscape.md (sync engines, file sync, versioning).

Method

Browsed. Facts were gathered with web search and page fetch against official vendor documentation, official pricing pages, official GitHub repositories and official release pages. Every URL below was accessed in 2026 (research date 2026-10-20). Claims that could not be confirmed on an official page are written [unverified]; no version number, price or API name is stated unless an official page stated it. Absence claims ("product has no comments") are labelled as absences and are [unverified] where no official page positively states the absence. Third-party sources appear only for user complaints and are labelled as such. Local grounding (SPEC.md, specs/collaboration/spec.md, specs/capture-and-publish/spec.md) was read from this repo to decide the "matters for NotesCraft" column.

Findings

Obsidian family

  1. Obsidian Sync's shared vault is file-level collaboration, not live editing — and Obsidian says so plainly. A shared remote vault is invited by email; all collaborators need their own active Sync subscription; joining a shared vault does not count against the vault limit. On permissions: "Fine-grained permissions are not supported yet. All collaborators receive the same permissions as the vault owner, with one exception: only the vault owner can invite collaborators." On live editing: "Obsidian does not yet support collaborative live editing on the same file. You will not see the other user's cursor, and their edits will only appear once the changes are synced"; concurrent edits to one file "will be merged" during sync and can be inspected and restored with Version history. Limit: max 20 collaborators per shared vault. E2EE shared vaults require every collaborator to enter the encryption password at setup. https://obsidian.md/help/sync/collaborate, https://obsidian.md/help/sync/faq (accessed 2026)

  2. The gap Obsidian leaves open is exactly NotesCraft's v1: a shared unit with fine-grained roles and live cursors on a plain .md file. Obsidian gives a shared vault with a single all-powerful role (minus inviting), no cursor, no presence, no live merge. NotesCraft's spec (owner / editor / viewer, one shared vault mounted as a folder, ephemeral presence) is a strict superset of what Obsidian Sync ships — the differentiation must be cheap to run on one homelab server, which it is: role checks in one middleware, presence in memory, no per-user billing. https://obsidian.md/help/sync/collaborate (accessed 2026)

  3. Obsidian's collaboration story is the strongest argument for plain files as the truth. Because a collaborator's edit arrives as an ordinary file change, the vault stays a normal Obsidian vault and every other tool (git, Quartz, any Markdown editor) keeps working. The price is that convergence is eventual and the last-writer's merge can interleave text. Nothing in Obsidian's docs suggests a block/CRDT format for shared vaults; shared vaults are ordinary .md files with ordinary conflict rules. https://obsidian.md/help/sync/collaborate, https://obsidian.md/help/sync/troubleshoot (accessed 2026)

Apple Notes / iCloud (the best-behaved consumer collaboration)

  1. Apple Notes is the most complete consumer collaboration model in the landscape, and it is a plain-text-per-note, folder-scoped, real-time model. Sharing a note or a folder of notes with a link; "All participants who have the note open can see the changes you and others make in near real time"; participants need an Apple Account, and Notes must be enabled in iCloud settings. Sharing options: "People you choose" (optionally with Access Requests) or "Anyone with the link"; permissions Edit or View and Download Only. On iPad the equivalent string is "Only invited people can edit". Locked notes cannot be shared, and a folder containing a locked note cannot be shared. https://support.apple.com/guide/iphone/share-and-collaborate-iphe4d04f674/ios, https://support.apple.com/guide/icloud/share-folders-mmbc2b562111/icloud (accessed 2026)

  2. Apple's presence and attribution UX is the best in any consumer notes app, and it is cheap to copy: colour-coded cursors + colour-coded highlights + an activity view. "Participants who have two-factor authentication enabled and iCloud Keychain turned on … can see others' changes immediately, and color-coded triangles show where others are working in the note." Highlights: swipe right on a note (or Show Highlights) to see the name of each participant and the time they last edited the note, colour-coded to match the text they changed. Activity view: Show Updates (changes since you last opened), Show All Activity (a day-to-day list per participant), and clicking a name highlights that person's changes in the note. A small yellow/orange dot appears next to a note that changed while you were away. Folder-level activity exists too (Show Folder Activity). https://support.apple.com/guide/notes/collaborate-with-shared-notes-and-folders-apd4e6e2c9a6/mac, https://support.apple.com/guide/iphone/share-and-collaborate-iphe4d04f674/ios (accessed 2026)

  3. Apple's role taxonomy for a shared folder is exactly the one NotesCraft already chose, plus one level. Per-note/folder participants can be given: View (copy the link, leave, choose highlight/notification display), Edit (edit, add/delete notes and subfolders, move notes out), Co-Owner (all of the above plus change sharing settings), and Owner (must transfer ownership before leaving). Anyone with the "can add other people" permission can also add/remove participants; any participant can remove themselves. Stop Sharing deletes the shared note or folder from the other participants' devices. https://support.apple.com/guide/notes/manage-shared-notes-and-folders-apd881ec5518/mac (accessed 2026)

  4. Apple's mentions and notifications are minimal and mostly local. @ + a participant's name mentions them and notifies them; mentions require iOS/iPadOS 14.5+ / macOS 11.3+, and a note containing a mention is hidden on older devices — a compatibility landmine worth avoiding. Participants can "Hide alerts" per note (not per folder), and an owner's choice does not affect a participant's viewing preference. Sharing through Messages surfaces activity updates in the Messages conversation. There is no server-side activity feed, no comment threads, and no suggestion mode — Apple's collaboration model is shared text, not review. https://support.apple.com/guide/notes/manage-shared-notes-and-folders-apd881ec5518/mac, https://support.apple.com/guide/notes/collaborate-with-shared-notes-and-folders-apd4e6e2c9a6/mac (accessed 2026)

Anytype

  1. Anytype has the most detailed documented role taxonomy of the products surveyed, and it is one level richer than NotesCraft's. Roles per shared space: Viewer (read only, cannot chat or delete), Editor (edit and permanently delete items, edit the space name), Admin (manage Editors and Viewers), Owner (create Admins, create invitation links, transfer ownership). "You cannot set permissions on a per-Object basis. All Space Members can view everything inside a Space." Invitation links come in three flavours — Editor, Viewer and Request Access — with auto-approval a toggle, a Reset Link action that voids a leaked link, and an explicit warning: "If it is intercepted, it can be used to gain access to the space without approval." https://doc.anytype.io/anytype/collaborate/collaboration, https://doc.anytype.io/anytype/settings/channel-settings (accessed 2026)

  2. Anytype's collaboration is local-first and E2EE with peer-to-peer sync, which is exactly the trade NotesCraft's spec rejects — and the reason is instructive. "Your device holds the keys: when you create a shared space, your device generates unique encryption keys … servers act as blind couriers"; offline edits "queue for sync once back online"; collaborators can join without email or a subscription. Sharing is at Channel granularity only ("Currently, you can only share entire Channels — not individual Objects"); publishing a single object publicly is a separate Web Publishing feature. The trade: notes are an object graph, not Markdown files, so a plain-file vault cannot inherit this design without changing the file format. https://doc.anytype.io/anytype/collaborate/collaboration (accessed 2026)

  3. Anytype's comments are attached to objects, not to text ranges — a deliberate simplification worth copying for Markdown. A Discussion is a thread attached to one Object, supporting attachments, inline @ mentions of people and objects, formatting, checkboxes and code blocks; posts can be edited, reacted to with emoji, replied to (threaded), and deleted. Permission rule: "Owners and Editors can post … Viewers can read Discussions but cannot post." If the Object is deleted, the Discussion goes with it. Notification modes: Enable all / Mentions only / Disable all, per Object, on top of a Channel default. https://doc.anytype.io/anytype/collaborate/discussions, https://doc.anytype.io/anytype/settings/channel-settings (accessed 2026)

Logseq

  1. Logseq's file version refuses collaboration outright; the DB version's RTC is database-native, which is the clearest evidence in the market that real-time collaboration and "Markdown files as the truth" pull in opposite directions. The file version ("Logseq OG") stores plain Markdown and its docs say the file-version sync did not support collaboration. The DB version stores the graph in SQLite and its sync is called RTC (Real Time Collaboration) — "this sync supports collaboration between users in real time like Google Docs". RTC is a paid, invite-only feature that "can also be self hosted". The community FAQ states the trade plainly: "In the DB version, while you will be able to export to markdown files, the database version is always canonical", "you cannot modify it" directly, and "Some flexibility is lost as a result, but in exchange we will get better sync, real time collaboration (RTC), and less data loss." https://github.com/logseq/docs/blob/master/db-version.md, https://logseq.io/page/e87c7359-51f7-44fe-87b3-4a0cd9f2dee3/695feeec-88be-4c5b-8bf2-572513c2f730 (accessed 2026)

  2. Logseq's RTC transport is a WebSocket protocol with rebase, presence and E2EE keys — the closest published analogue to NotesCraft's planned design, and it is worth reading as a reference implementation. Logseq's merged PR "Sync with Cloudflare DO" (merged 2026-02-12) introduces a "db-sync worker (Cloudflare DO) for real-time collaboration" with a WebSocket and HTTP API for graph sync, presence, and assets, a client runtime with rebase, conflict resolution and undo/redo improvements, and "undo/redo to scope history to local changes only, preventing remote updates from entering the undo stack". It also adds presence tracking ("editing presence, avatars, debounced presence updates"), an RTC indicator with a pending-server-ops display, an editing-user avatar on the block being edited, E2EE key management, remove-member and leave-graph flows, and self-hosted deployment (Cloudflare or local Node.js server). It ships protocol docs (docs/agent-guide/db-sync/protocol.md) and a rebase design note (rebase.md). https://github.com/logseq/logseq/pull/12315 (accessed 2026)

  3. Logseq's per-object attribution (created-by, created-by-ref) is a concrete pattern for "who changed what" that a plain-Markdown vault can copy with frontmatter. Logseq's DB changelog records the addition of a :logseq.property/created-by-ref property and a :logseq.property/created-by property, plus per-block property history and a status history view for tasks, and a created-by pipeline hook. In a Markdown app the same idea is frontmatter (created_by, created_at, updated_by, updated_at) — which Obsidian-compatible tools ignore gracefully. https://discuss.logseq.com/t/logseq-db-changelog/30013 (accessed 2026)

  4. Logseq's publishing is per page, optional password, self-hostable, and its search excludes password-protected pages — a small, correct privacy rule NotesCraft's publish should copy. "Logseq Publish allows users to share pages of any graph. Pages are published to logseq.io with CloudFlare and can be optionally password protected. The published page is a read-only, minimal outliner." A published page carries a Published URL property and an Unpublish action; "To update local changes to the page, simply re-publish." Search across published pages exists, and "If a page is password protected, it is excluded from search results to ensure its privacy." Customisation is done by editing publish.css and publish.js pages. Self-hosting uses a Publish Server URL setting (a Cloudflare account is still required). https://github.com/logseq/docs/blob/master/db-version.md (accessed 2026)

Standard Notes

  1. Standard Notes is the control case: the most privacy-correct product in the survey has no collaboration at all, and that is a deliberate design consequence, not a missing feature. The published plan ladder (Standard Free / Productivity $90/year / Professional $120/year) lists editing modes, files, storage and history, and contains no collaboration, comment, presence or sharing-of-content feature at all; the only sharing item is "Subscription sharing with up to 5 accounts" — sharing plan benefits and quota, not notes. Notes are XChaCha20-Poly1305 encrypted, the server is zero-knowledge, and sync is client-driven. The reason no collaboration exists is the same reason NotesCraft excludes live editing in E2EE vaults: a server that must parse content to order edits cannot also be blind to content. The sibling sync research records the official refusal on the grounds that "server-side collaboration would require the server to parse content". https://standardnotes.com/plans, https://standardnotes.com/help/3/how-does-standard-notes-secure-my-notes (accessed 2026)

  2. Standard Notes' history model is plan-shaped and per-note: a useful precedent for NotesCraft's planned attribution/revision work, and a warning about who pays for retention. The feature table lists "Current session only" (free), "1 Year" (Productivity) and "Unlimited" (Professional) note revision history, and the sibling research records that Standard Notes' Remote History is a paid-only extra and that restoring is restore-overwrite or restore-as-copy. For a self-hosted NotesCraft the equivalent knob is a per-vault retention setting plus a stored editor per revision. https://standardnotes.com/plans (accessed 2026)

Cross-cutting findings

  1. Nobody in the survey ships a per-note or per-folder ACL that works on plain files, which is the clearest open gap for NotesCraft. Obsidian: one role for all collaborators on a shared vault. Apple: folder-level roles (View / Edit / Co-Owner / Owner) but Apple Notes are not files. Anytype: space-level roles with "no permissions on a per-Object basis". Logseq RTC: graph-level. Standard Notes: none. NotesCraft's "shared vault mounted as a folder, with a role per vault" is a coherent subset of Apple's model and strictly finer than Obsidian's.

  2. Live editing over plain text is proven at Google-Docs scale but has never been shipped by a Markdown-first product — the two are usually treated as incompatible, and only Logseq's DB version crossed the line, at the cost of the Markdown file. NotesCraft's bet (server-ordered OT over the plain .md bytes, with the file as the canonical form) is therefore unproven but cheap, and the closest published precedent is Logseq's own "rebase" design: the server orders operations, the client rebases local pending operations against the acknowledged base — exactly the shape of the TextOp transform/compose/invert machinery already specified in specs/collaboration/spec.md. https://github.com/logseq/logseq/pull/12315 (accessed 2026)

  3. The "who changed what" question has three different answers in the market, and only one of them fits plain files. Apple answers it with per-user colour-coded highlights computed client-side from change history; Logseq answers it with per-object created-by properties and property history stored in the database; Standard Notes answers it with per-note revision history with restore. For a plain-Markdown vault the durable, portable answer is a server-side revision ledger that stores author + time + op per revision (the sync server already has one) and renders it as Apple-style coloured highlights, with updated_by/updated_at written into frontmatter as a convenience.

  4. Comments and suggestions are consistently absent from file-based products and present in database products, and they are attached to objects, not to text ranges. Anytype's Discussion is attached to an Object; Notion and Google Docs attach comments to a block/range but need the block identity to survive. A Markdown file has neither: a comment anchored to "line 12" rots the moment the paragraph moves. The only anchor that survives a plain file is a text-quote anchor (a short quoted snippet), which is what a plain-file app must use.

Obsidian's community collaboration plugins (the CRDT wave)

  1. Relay is the closest product to NotesCraft's goal and the strongest evidence that "CRDT underneath, Markdown on top" is a real, shipping architecture. Relay is a "multiplayer mode for Obsidian": share folders (not whole vaults) with live cursors. Its transport is WebSocket + Yjs CRDT against a y-sweet fork, but its storage is plain Markdown on disk: the server keeps Yjs doc state plus file copies, and a "merge HSM" reconciles disk ↔ local CRDT ↔ remote CRDT, falling back to diff3 for offline merges. Version 0.8.12 (2026-09-09) rewrote the sync engine so external on-disk edits are ingested and merged — i.e. an agent or script editing the .md does not lose writes. https://github.com/no-instructions/Relay, https://github.com/no-instructions/Relay/tree/main/src/merge-hsm, https://relay.md/releases (accessed 2026)

  2. Relay's access model is the exact opposite of NotesCraft's: a share key, not roles. "Anyone with the share key can join"; removing someone does not stop them rejoining; the paid Private toggle adds a per-folder user allow-list, but "Relay does not currently support read-only access for Shared Folders" — there is no owner/editor/viewer ladder. Relay does allow free self-hosting on every plan (server = y-sweet fork + S3-compatible storage), but the control plane for accounts and permissions stays in Relay's cloud, and the hosted service is not end-to-end encrypted. Pricing pages (relay.md / system3.md): Free $0 (≤3 users), Hobby $5/mo total, Starter $6 per user/mo (RBAC on private folders, SSO), Premium $18 per user/mo. The README and pricing page disagree on Starter limits — treat the pricing page as newer and re-verify before quoting. https://relay.md/pricing, https://docs.relay.md/guides/private-shared-folders, https://docs.relay.md/guides/choose-how-to-host-relay, https://docs.relay.md/how-relay-works/what-relay-can-see (accessed 2026)

  3. Peerdraft is Yjs again, SaaS-only, and offers a shape NotesCraft may want later: a web editor for people who do not have the app. Transport is Yjs CRDT over WebSocket (plus y-webrtc peer-to-peer for ad-hoc "fleeting" sessions where "no content passes through Peerdraft servers"); shared notes land in the vault as plain Markdown under a configurable root folder; persistent shares are "encrypted in transit and at rest, stored on Peerdraft servers"; local CRDT state is kept in IndexedDB. Access is share-URL only ("Only people with the share URL can access your documents") and no self-hosting is documented. It also ships a REST API and an MCP server. Pricing as listed on peerdraft.app: Free (unlimited fleeting sessions, ≤10 persistent shares), Pro $5/mo billed annually or $6/mo monthly, Business custom. Peerdraft's own README, pricing page and changelog give inconsistent tier names and prices — quote only with a date attached. Releases: v2.23.3 on 2026-08-25. https://github.com/peerdraft/obsidian-plugin, https://www.peerdraft.app/#pricing, https://www.peerdraft.app/documentation/ (accessed 2026)

  4. Relay Comments shows the only working way to put Google-Docs-style review into a plain Markdown file: CriticMarkup in the note itself. Comments and suggestions are written into the Markdown as CriticMarkup and diff against the note; no network calls, no telemetry, identity comes from Relay/Obsidian Sync. This is the cheapest possible suggestion/comment layer for a file-as-truth app — it needs no database, survives every exporter, and can be rendered by any Markdown tool. https://github.com/no-instructions/Relay-Comments (accessed 2026)

  5. One-way encrypted share links exist as Obsidian plugins and are a cheap tier neither Relay, Peerdraft nor Obsidian Publish provides. Share Note publishes one note read-only with your full theme/CSS, encrypted by default with the key in the URL fragment ("nobody else can read the content — not even the hosting server"). CMDS Share publishes a note/bases/ canvas to GitHub Pages or a managed backend with optional encryption and host-dependent expiry/view-counts/revoke. QuickShare offers AES-256-CBC encrypted note links and self-hostable storage but its last release was 2023-01-07 (effectively unmaintained). Other community entries (Flowershow, Nectenda, Obsidian Collab, Collaborative Folders, Shared Vault, Live Share) are small and unvetted. https://github.com/alangrainger/share-note, https://github.com/johnfkoo951/cmds-share, https://github.com/mcndt/obsidian-quickshare, https://github.com/obsidianmd/obsidian-releases/blob/master/community-plugins.json (accessed 2026)

Obsidian Publish

  1. Obsidian Publish is a read-only projection with a site-level model, priced per site, and it is the reference for NotesCraft's planned publish feature. A site is published at publish.obsidian.md/<site-id>; only published notes leave the vault; rendering is Obsidian's own; features include hover previews, graph view, stacked pages, backlinks, TOC, full-text search, mobile-friendly layout and automatic SEO/social cards. Theming = drop publish.css, publish.js and favicon-*.png in the vault root (a community theme = copy its CSS to publish.css); theme picker = Light / Dark / Adapt to System; Style Settings does not work on Publish. Custom domains work but Cloudflare is the only officially supported provider (CNAME → publish-main.obsidian.md, SSL mode Full); otherwise you reverse-proxy to https://publish.obsidian.md/serve?url=<your-domain>/<path> and Obsidian does not provision certificates. Search is basic: plain text only, preference order file names → aliases → header names → body, with no embedded search results. Collaborator roles are binary Owner vs Collaborator; collaborators may publish, update and unpublish pages but cannot configure the site or manage permissions, and only the owner needs a paid subscription. Pricing $8 per site per month billed annually, $10 monthly. Not included: per-page version history (a Sync feature only), native comments, per-note passwords, Canvas and Bases support (both Planned on the Obsidian roadmap), files over 50 MB, and true simultaneous multi-author editing. https://obsidian.md/publish, https://help.obsidian.md/publish/sites, https://help.obsidian.md/publish/security, https://help.obsidian.md/publish/domains, https://help.obsidian.md/publish/collaborate, https://help.obsidian.md/publish/limitations, https://help.obsidian.md/publish/customize (accessed 2026)

  2. Publish collaboration is manual, not synced — the exact failure mode NotesCraft's OT removes. Obsidian warns that collaborators must pull the live version or use Obsidian Sync/git, "otherwise you risk overwriting changes from other collaborators". Access control is site-level passwords (multiple passwords, each with a nickname) and "Individual password protection for published notes is currently not supported". NotesCraft's share links (per-note, expiring, server-validated) are strictly finer-grained than anything Publish offers. https://help.obsidian.md/publish/collaborate, https://help.obsidian.md/publish/security (accessed 2026)

Notion

  1. Notion's permission taxonomy is the richest in the survey and maps cleanly onto NotesCraft's three roles plus one. Per person/group/teamspace: Full access (edit + re-share), Can edit (no re-share), Can comment (no edit/share), Can view (no comment/edit/share); database-only extras "Can edit content" and "Can create". General access options: Only people invited, Everyone at {workspace} (with "Hide in search"), and Anyone on the web with link, which supports "Link expires" set to a time or date. Guests are people outside the workspace who need their own account and are bounded by guest/allowed-domain/Enterprise policy. Notion respects the broadest level of access given to a user and subpages inherit parent permissions — a page under a broadly shared parent may be reachable via link. https://www.notion.com/help/sharing-and-permissions (accessed 2026)

  2. Notion's presence UX is the most copyable of the big two, and it is nearly free. "You can edit the same page at the same time with an unlimited number of people"; edits and comments "appear to you instantly"; added content is highlighted blue, removals grey strikethrough. Presence is per block — "their avatars move next to the blocks they are looking at or editing". The avatar bar at the top of a page shows faded avatars for people who are not currently on the page and unfaded for those who are; hover shows name, email and last-seen time; clicking an active avatar jumps you to where that person is reading or typing. A "🕘" button shows who made what changes and when. https://www.notion.com/help/collaborate-with-people, https://www.notion.com/help/sharing-and-permissions (accessed 2026)

  3. Notion's suggestion mode is a separate channel that does not mutate the document until accepted — the pattern NotesCraft should copy if it ever ships review. "••• → Suggest edits" requires Can comment or above; only text, to-do, heading, bulleted and numbered list blocks can be suggested (not inline databases, properties or peek); each suggestion can be accepted, rejected, reacted to or replied to; "Lock page" blocks suggestions entirely. Notion's comments are top-level page discussions plus inline ones (select text, or block ⋮⋮ → Comment, or ⌘/Ctrl+Shift+M), with resolve/reopen, filters by person and open/resolved, and emoji reactions. @mentions cover people, groups, pages and dates, land in the Inbox with a badge, and jump to the exact line; "@-mentions and comment replies always come through and can't be filtered off". https://www.notion.com/help/suggested-edits, https://www.notion.com/help/comments-mentions-and-reminders, https://www.notion.com/help/updates-and-notifications (accessed 2026)

  4. Notion's publishing leaks contributor identity by default and has no password — two hard warnings for NotesCraft's public publish. Published pages are "Notion Sites"; publishing a page publishes all of its subpages (subpages can be restricted individually); sites auto-update as the page changes; slug ≤60 characters, manual, not reusable after permanent delete; "Discoverable on the web" toggle; "Notion Sites can take up to four weeks to be indexed". Custom domain is a paid add-on (+$10/month, +$8/month with annual billing) with CNAME to external.notion.site plus a TXT record. Password: "Can I password protect a page? Unfortunately, not at the moment." And: "the webpage's metadata will include the names, profile photos, and email addresses associated with any Notion users that have contributed to the page". https://www.notion.com/help/public-pages-and-web-publishing, https://www.notion.com/help/connect-a-custom-domain-with-notion-sites (accessed 2026)

Google Docs

  1. Google Docs is the OT reference implementation and the only product in the survey that publishes co-editing on a plain Markdown file. Its help centre documents the observable contract, not the algorithm; the algorithm is widely attributed to a 2010 Google whitepaper that could not be retrieved during this research, so the internal OT-vs-CRDT choice is [unverified]. What is documented: the same file can be open for editing on up to 100 tabs/devices (beyond that only the owner and some editors can edit) with up to 600 email addresses per file; collaborators appear as avatars top-right with a "+N" overflow circle; an in-file chat is visible to anyone viewing the file and is not saved. Crucially for NotesCraft: Google Drive/Docs now opens plain .md files in "Markdown Mode" and keeps them as .md, with sharing, comments and co-editing on the Markdown file itself. https://support.google.com/docs/answer/7068618, https://support.google.com/docs/answer/2494891, https://support.google.com/docs/answer/18289341 (accessed 2026)

  2. Google's role matrix is the one to copy for a homelab: Viewer / Commenter / Editor / Owner, plus link sharing that works without signing in. My Drive roles: Viewer (view + download by default), Commenter (view + comment), Editor (edit, share, change permissions by default, cannot change owner), Owner; download/print/copy can be restricted per role and the owner can uncheck "Editors can change permissions and share". General access: Public, Anyone with the link (with a separately chosen role, usable without signing in), or Restricted. Link expiry exists only as a per-user "Add expiration" and is eligible work/school accounts only — there is no "off-link" switch. Inheritance is one-way: "Access you apply to a folder is inherited by all files within it. You can no longer give someone less access to an individual file if they have higher access to its parent folder." Signed-out visitors appear as "anonymous animals" and see the owner's name and email. https://support.google.com/docs/answer/2494822, https://support.google.com/docs/answer/2494893, https://support.google.com/docs/answer/2494888 (accessed 2026)

  3. Google's suggestion mode and its attribution features are the two most transferable ideas in the whole survey. Suggesting is a mode switch next to Editing; selecting text offers "Suggest edits"; suggested insertions appear in a new colour, deletions are crossed out; each suggestion takes a comment/reply; the owner is emailed; accept/reject one by one or Accept all / Reject all via Tools → Review suggested edits; Commenter and Editor may suggest; Microsoft Office tracked changes and Docs suggestions map both ways. Attribution: "Last edit" shows who updated last and when, with a blue dot for "changed since you last viewed"; "Name this version" gives up to 40 named versions per document; right-click a selection → "Show editors" to see who changed that exact text (paid tiers only); Drive's Activity panel logs edits, comments, renames, moves, uploads, share/unshare; the Drive API exposes revisions with keepForever, lastModifyingUser and version. https://support.google.com/docs/answer/6033474, https://support.google.com/docs/answer/190843, https://support.google.com/docs/answer/9331169, https://support.google.com/drive/answer/2409045, https://developers.google.com/workspace/drive/api/reference/rest/v3/files (accessed 2026)

HedgeDoc and Outline (the self-hosted CRDT reference implementations)

  1. HedgeDoc 1.x is the proof that server-ordered OT on Markdown works in production — it is literally OT.js. "HedgeDoc uses a vendored version of OT.js. The source code lives under public/vendor/ot/", with text-operation.js, wrapped-operation.js, selection.js, undo-manager.js and socketio-adapter.js; the transport is socket.io. Its permission model is a note-level dropdown: Freely / Editable / Limited / Locked / Protected / Private, over owner / signed-in / guest, changeable only by the owner. Its API exposes /<NOTE>/revision returning "the content of the note and the authorship", plus /<NOTE>/publish, /<NOTE>/slide and /<NOTE>/download. HedgeDoc is AGPL-3.0 — learn from it, never copy it. https://github.com/hedgedoc/hedgedoc/blob/master/docs/content/dev/ot.md, https://github.com/hedgedoc/hedgedoc/blob/master/docs/content/references/permissions.md, https://github.com/hedgedoc/hedgedoc/blob/master/docs/content/dev/api.md (accessed 2026)

  2. HedgeDoc 2 moved to Yjs and shows the exact CRDT-over-Markdown shape NotesCraft would be adopting if it changed course — one Y.Text channel holding the whole Markdown. yjs 13.6.32 on both backend and frontend; the body lives in a plain Y.Text named markdownContent; realtime is a custom JSON protocol over WebSocket (message types like NOTE_CONTENT_STATE_REQUEST, NOTE_CONTENT_UPDATE, REALTIME_USER_SINGLE_UPDATE, REALTIME_USER_SET_ACTIVITY) carrying Yjs updates, not y-protocols; presence is an ephemeral per-user adapter (cursor: {from,to}, active flag). Permissions are DENY | READ | WRITE | FULL with additive per-user and per-group grants (special groups LOGGED_IN, EVERYONE); revisions are a separate service carrying authorship. HedgeDoc 2 is 2.0.0-alpha.3 on develop, and a tree scan found no comments and no publish/public sharing in that tree [unverified, absence by tree scan]. https://github.com/hedgedoc/hedgedoc/blob/develop/commons/src/y-doc-sync/realtime-doc.ts, https://github.com/hedgedoc/hedgedoc/blob/develop/commons/src/message-transporters/message.ts, https://github.com/hedgedoc/hedgedoc/blob/develop/commons/src/permissions/permissions.ts, https://docs.hedgedoc.dev/concepts/notes/ (accessed 2026)

  3. Outline is the best-documented self-hosted wiki with CRDT collaboration, and it proves the cost: Markdown becomes a projection of a CRDT document. Collaboration is Yjs via Hocuspocus over WebSocket at /collaboration (@hocuspocus/server, y-protocols, y-prosemirror); Outline has used Hocuspocus since at least 2021 and has never been OT. Storage is triple: document.text (TEXT = markdown), document.content (JSONB = ProseMirror) and document.state (BLOB = Yjs state), plus revisionCount and publishedAt. Presence rides Yjs Awareness (state.cursor). Permissions are read | read_write | admin for collections and documents, resolved by priority; the UI labels them "View only" / "Can edit", and the i18n states "Editors can create, edit, and comment" while "Viewers can only view and comment" — there is no separate commenter role. Comments with threads, reactions and "mentioned you in" exist; share links are team.url/s/<urlId>; public sharing is a publish flag plus a collection setting "Public document sharing"; history is a revisions table with a user relation, and per-save attribution is tracked as a Redis sorted set of collaborators (lastEditors). Self-hosting is Docker Compose with postgres + redis; the API is RPC-style POST https://<host>/api/:method with a Bearer key and an OpenAPI 3.0.0 document. Outline is Business Source License 1.1 — not OSI open source. https://github.com/outline/outline/blob/main/server/services/collaboration.ts, https://github.com/outline/outline/blob/main/server/models/Document.ts, https://github.com/outline/outline/blob/main/shared/types/permissions.ts, https://github.com/outline/outline/blob/main/server/models/Revision.ts, https://www.getoutline.com/developers (accessed 2026)

The libraries

  1. The library landscape says the same thing from four directions: OT has no Rust ecosystem, CRDTs have three good ones, and none of them keeps a plain Markdown file as the truth. Yjs (MIT) is the reference CRDT: updates are commutative, associative and idempotent (order-independent offline merge), Y.Text is the text type with UTF-16 code-unit positions, presence is a separate Awareness CRDT that is not stored in the document, and persistence is a binary update log (y-indexeddb, y-postgresql, y-redis; y-leveldb is marked deprecated). The Rust binding is yrs 0.28.0, MIT, binary-compatible with Yjs, with yrs-warp 0.9.0 as a server. Automerge (Rust crate automerge 0.12.0, MIT) makes every string a collaborative text object editable only via splice/updateText, with peritext marks — but its npm latest is 2.0.0-alpha.3 and a 2→3 migration guide is published, so the API is in flux. Loro is the only Rust-first CRDT (crate loro 1.16.2, MIT; JS/WASM loro-crdt 1.16.4) with Unicode-scalar text positions and built-in version history (export/checkout/diff/oplog_vv); no Rust sync-server crate, but loro-websocket 0.6.2 ships a client and a SimpleServer. ShareDB is the Node OT server (npm sharedb 6.0.5, MIT) with default type ot-json0 and a plain-text type ot-text that "can be used to edit plaintext documents, like sourcecode or markdown" but counts UTF-16 offsets and is "incompatible with ot implementations in other languages"; presence is only supported by the rich-text type; access control is middleware over connect/receive/reply/ submitOp; history uses snapshots and milestone snapshots. The decisive Rust fact: a crates.io full-text search for "operational transformation" surfaces only operational-transform 0.6.1 (last release 2022-02-12, library only, no server) and ot-rs 0.1.0 (2021) — no maintained Rust OT server framework exists. https://docs.yjs.dev/api/document-updates.md, https://docs.yjs.dev/getting-started/adding-awareness.md, https://docs.rs/yrs/, https://crates.io/crates/automerge, https://automerge.org/docs/guides/migrating-from-automerge-2-to-automerge-3/, https://docs.rs/loro/, https://docs.rs/loro/latest/loro/struct.LoroDoc.html, https://share.github.io/sharedb/, https://github.com/ottypes/text, https://github.com/share/sharedb/blob/main/docs/presence.md, https://crates.io/crates/operational-transform (accessed 2026)

  2. Therefore: keep the in-house server-ordered OT. Reasons that survive the landscape: (a) every Rust-native CRDT turns the .md into a projection of a binary document — exactly the property NotesCraft must not lose; (b) the only maintained OT server is Node (ShareDB), so "adopt a library" for OT means adding a Node service to a Rust homelab; (c) a single homelab server is the natural ordering point — HedgeDoc 1.x proves the pattern in production with OT.js; (d) OT keeps one canonical text and a linear revision history for free, which the existing versions/history surfaces consume directly. The cost to accept: OT needs the server online for the live path, so long offline divergence degrades to "rejoin with snapshot". If multi-week offline multi-writer editing ever becomes a hard requirement, the cheapest migration is yrs + one Y.Text per note (HedgeDoc 2's markdownContent shape) with loro the runner-up for its native history and scalar offsets.

Publishing a Markdown vault to the web

  1. Quartz is the closest open-source analogue to NotesCraft's planned publish feature, and it is a static generator with no auth — which is precisely the gap. Quartz turns a content/ Markdown folder into a static site through a plugin pipeline (Transformers, Filters, Page Types, Components, Emitters); v5 moved config to quartz.config.yaml and plugins to standalone repos (npx quartz plugin add github:quartz-community/<name>, 40+ official plugins). Features: client-side full-text search (Flexsearch, sub-10 ms, needs the ContentIndex emitter), and backlinks / graph / tags / dark mode as opt-in plugins. Theming is theme.typography/theme.colors plus quartz/styles/custom.scss; deployment is GitHub Pages, Cloudflare Pages, Vercel, Netlify, GitLab Pages or self-host behind nginx/apache/caddy (try_files $uri $uri.html) — reverse-proxy friendly; v5 prefers relative URLs so it works from any path. Multi-user or live editing: none — the output is static; the closest is Giscus comments, which require a public GitHub repository. Visibility is three plugins: draft (default), ExplicitPublish (publish: true) and UnlistedPages (unlisted: true removes the page from index/RSS/sitemap/graph/search but the HTML is still emitted and reachable by URL), plus EncryptedPages (per-page password, AES-256-GCM + PBDF2 600 000 iterations, client-side decrypt) — with no expiry, no revocation and no server-side auth. Documented trap: "all non-markdown files will be emitted and available publically in the final build" — attachments leak. https://quartz.jzhao.xyz/, https://quartz.jzhao.xyz/features/full-text-search, https://quartz.jzhao.xyz/plugins/UnlistedPages, https://quartz.jzhao.xyz/plugins/EncryptedPages, https://quartz.jzhao.xyz/hosting (accessed 2026)

  2. MkDocs/Material is the other reference but it is now a maintenance-only path — do not build NotesCraft's publish on its idioms. MkDocs stable is 1.6.1 (BSD-2-Clause) with 2.0.dev* pre-releases; Material for MkDocs is 9.7.7, MIT, with plugins for blog, group, info, meta, offline, optimize, privacy (self-hosts external assets), projects, search, social, tags and typeset, plus versioning through the external mike tool. Neither tool supports multi-user editing — the output is plain static files with no server or auth layer. Lifecycle: Material feature development ended, with critical maintenance only through May 5, 2027; the MkDocs 1.x repo closed to outside contributions on 2026-10-02; MkDocs 2.0 is incompatible with Material (no plugin system, TOML config, rewritten theming); the successor is Zensical (MIT, still alpha). https://pypi.org/project/mkdocs/, https://pypi.org/project/mkdocs-material/, https://squidfunk.github.io/mkdocs-material/plugins/, https://squidfunk.github.io/mkdocs-material/setup/setting-up-versioning/, https://squidfunk.github.io/mkdocs-material/blog/2025/11/05/zensical/ (accessed 2026)

  3. HedgeDoc is the only tool surveyed with documented abuse controls, and NotesCraft's share links need exactly that. HedgeDoc 1.12.0 documents per-tier rate limits (public API 150/300 s, authenticated 900/300 s, unauthenticated 100/300 s, auth 40/900 s) answering 429 with X-RateLimit-Limit/Remaining/Reset and Retry-After, per-IP for anonymous visitors, with an allow-list for trusted IPs. HedgeDoc 2's realtime adds per-IP limits in the same family. Static generators (Quartz, MkDocs, Hugo, Docusaurus) have zero built-in auth, and Quartz's client-side password "protects against casual browsing but not against determined attackers". https://github.com/hedgedoc/hedgedoc/blob/develop/docs/content/references/config/security.md, https://quartz.jzhao.xyz/plugins/EncryptedPages (accessed 2026)

  4. Two more self-hosted references worth knowing: SilverBullet and SiYuan. SilverBullet keeps plain-Markdown spaces on your disk and can "Publish it, if you want to" — one dashboard setting gives public read access to a space with no account; its own "Share" feature is provider-based push/pull sync, not web publishing, and it explicitly suggests publishing a space with Quartz/MkDocs/Hugo. SiYuan self-hosts with an access code or OIDC and exposes file-level publish-access endpoints, but the expiry/password semantics of published notebooks are not documented [unverified]. Dendron is "maintenance only, active development has ceased". https://silverbullet.md/docs-as-code, https://silverbullet.md/Share, https://github.com/siyuan-note/siyuan/blob/master/kernel/api/router.go, https://github.com/dendronhq/dendron (accessed 2026)

  5. Moderation for shared links is barely solved anywhere, which makes it a NotesCraft differentiator — but only if the checks are server-side. The documented toolkit is thin: password protection (Obsidian Publish site passwords; Quartz client-side AES-GCM; Logseq per-page password, with password-protected pages excluded from search), expiry (Notion "Link expires"; Google per-user expiry only for eligible accounts; Quartz none; Obsidian Publish none), rate limiting (HedgeDoc only), and kill switches (Notion Enterprise "Disable publishing sites, forms, and public links"). Nothing surveyed offers revocation of an already distributed link with a server-side check — Quartz's UnlistedPages is not access control, only de-indexing.

Feature table

Feature Who has it Why it matters for NotesCraft Effort Priority
Shared vault with owner / editor / viewer roles Anytype (Viewer/Editor/Admin/Owner, space-level only), Outline (read/read_write/admin), HedgeDoc 2 (DENY/READ/WRITE/FULL + additive grants), Notion (4 roles + guests), Google (Viewer/Commenter/Editor/Owner), Apple Notes (View/Edit/Co-Owner/Owner per folder) Obsidian's shared vault gives every collaborator the owner's power and no read-only tier; Relay has no read-only access at all. Our three roles are already in the spec and are strictly finer than Obsidian's and Relay's. S (already specced) P0
Live cursors + peer presence Notion (per-block avatars, faded/unfaded, click-to-jump), Apple Notes (colour-coded triangles + colour-coded highlights), Outline/HedgeDoc 2 (Yjs Awareness, ephemeral), Logseq DB (editing avatars + presence indicator), Google Docs (avatar strip, "+N") crates/collab already has Presence (name, colour, cursor, ephemeral, 30 s prune). Rendering it is the single cheapest "this is really collaborative" signal. S P0
Server-side per-link expiry and revocation Notion ("Link expires"), Google (per-user expiry, eligible accounts only), Logseq (per-page password, excluded from search) Nobody in the survey validates expiry or revocation server-side for a shared link. Our publish spec already promises an expiry token — this is the differentiator, and it must be server-side. S P0
Per-note share links from the same renderer as publish Obsidian Publish (site passwords only, no per-note), Quartz (UnlistedPages = de-index only, no access control), Logseq Publish (per-page password) specs/capture-and-publish/spec.md item 6 already says share links are "the same renderer behind a secret path". One renderer, two routes, one expiry check. S P0
Rate limiting + 429/Retry-After on anonymous routes HedgeDoc (documented per-tier limits, per-IP for anonymous) Share links are unauthenticated by design; without a limit one leaked URL is a scraping endpoint. S P0
Comment/suggestion layer stored in the Markdown (CriticMarkup) Relay Comments (CriticMarkup in the note, no DB), Google Docs (suggestions, accept/reject, accept-all), Notion (suggested edits, per-block only) The only anchor that survives a plain file. A separate comment DB needs range transforms and a second storage model; CriticMarkup needs neither and diffs with the OT op log. M P1
Suggestion op channel that does not mutate the document Google Docs (Suggesting mode), Notion (Suggest edits + Lock page) Review workflow without a second editor: proposals are ops held pending until accepted/rejected, individually or in bulk. M P1
"Last edit — who, when" per note + per-revision authorship Google Docs ("Last edit", named versions, "Show editors"), Notion ("who last edited"), HedgeDoc (/revision includes authorship), Logseq (created-by property), Standard Notes (per-note revision history) Our server already stamps each accepted op; surfacing it costs almost nothing and answers "who changed what" in a way no Markdown-first product does. S P0
Colour-coded per-user highlights of past edits Apple Notes (name + time + colour matching the changed text), Google Docs ("Show editors" on a selection, paid tiers) Needs a per-revision author, which the OT log already has. It is the highest-value "attribution" surface for a reviewer. M P1
Durable server-side activity feed + mentions inbox Notion (Inbox, badge, jump to line), Google Drive (Activity panel), Apple Notes (activity view, folder activity, @mentions) The sync-landscape research already argued a durable server log is the best trust signal a self-hosted service can offer; mentions are the payload that makes it useful. M P1
Role ceiling: no grant may exceed the member's vault role Google Drive ("You can no longer give someone less access to an individual file if they have higher access to its parent folder"), Notion ("broadest level of access wins") Prevents a per-note or per-share grant from silently widening access. One check in the server middleware. S P0
Offline edits rejoin the live room and rebase HedgeDoc 1.x (offline-tolerant), Relay (diff3 fallback, disk↔CRDT merge), Anytype (offline queue + P2P), Logseq (offline tests in db-sync) Our spec already promises "an edit made offline merges when I reconnect"; the merge substrate is merge3 + OT rebase. M P0
Crash-safe rejoin: resend unacked op once, end identical HedgeDoc 1.x (OT.js undo manager + socket adapter), Logseq db-sync (rebase, duplicate-order fix, snapshot framing) Already an acceptance criterion in specs/collaboration/spec.md; the reference implementations show it is a protocol concern, not a UI one. M P0
Read-only publish projection with a theme file Obsidian Publish (publish.css/publish.js in the vault root, Light/Dark/System), Quartz (custom.scss + config colors), Material (palette + toggle) One stylesheet + CSS variables + prefers-color-scheme; no theme engine. NotesCraft already renders Markdown with crates/markdown. S P1
Static client-side search index built from the published set Quartz (contentIndex.json + Flexsearch), Material (lunr search plugin), Obsidian Publish (basic full-text search) Search is expected on a published site, but the index is a leak surface: it must be generated from the same filtered set as the HTML, never from the vault. M P1
Custom domain on the owner's own server Quartz (CNAME + relative URLs, self-host behind any proxy), Obsidian Publish (Cloudflare only), Notion Sites (paid add-on, CNAME + TXT) Our homelab already runs Traefik; owning the hostname and TLS is free and removes a vendor dependency. S P1
Public/private separation with attachment filtering Quartz ("all non-markdown files will be emitted and available publically"), Notion (subpages inherit publication) Publishing a folder must not publish the vault's binaries or the unpublished subpages. Quartz shows the default is wrong. S P0
Strip author metadata from published HTML by default Notion ("the webpage's metadata will include the names, profile photos, and email addresses associated with any Notion users"), Google (link viewers see the owner's name/email) Publishing to the open web leaking the author name is a privacy surprise. Default to anonymous, opt in. S P1
Per-page password instead of a client-side one Quartz (EncryptedPages, client-side AES-256-GCM, "protects against casual browsing but not against determined attackers"), Logseq Publish (server-side per-page password) A client-side password is theatre; a server-side check is a feature. S P1
Headless publish / API for the site Quartz (no API), Obsidian Publish (a "Headless Publish" doc exists but no public API spec was read), Notion Sites (no publish API) If a script or an agent should publish, it needs a documented endpoint — and a human-only GUI is a bottleneck for a homelab. M P2
CRDT as the live substrate (one Y.Text per note) HedgeDoc 2 (markdownContent), Outline (Yjs + Hocuspocus, Markdown as projection), Relay (Yjs over WebSocket, Markdown on disk), Anytype (local-first CRDT) Only worth it if multi-week offline multi-writer editing becomes a hard requirement. yrs (MIT) is the cheapest Rust path; it makes the .md a projection, which conflicts with "files are the truth". L P2
Commenter role as a fourth tier Google (Commenter), Notion (Can comment), Outline (Viewers can view and comment) Only worth shipping with comments; the taxonomy is settled, the cost is the role matrix. S P2
Named versions with restore Google Docs (up to 40 named versions per document), Obsidian Sync (version history, 1 month / 12 months by plan) Named versions are a nicer restore UX than a raw revision list, and the OT log already holds the data. M P1
Access requests / approval inbox for invitees Notion ("Request edit access" → creator's Inbox), Apple Notes ("Access Requests"), Anytype (Request Access links + approval) NotesCraft's invite codes are owner-driven; a request flow removes the "ask the owner to make another code" dead end. M P2

Recommendations — the 10 features to build next

  1. Render the presence layer that already exists, and add a "last edit" line per note. Acceptance: with a second peer in the room, the editor shows that peer's name, colour and cursor within one frame of the peer's first keystroke, and each note shows "Last edit — , " taken from the accepted op's author, with no new persistence format.
  2. Ship expiring, revocable share links from the same renderer as publish, with server-side validation. Acceptance: a share link renders the note as static HTML, returns 404 after its expiry timestamp, returns 404 immediately after revocation, and never appears in the vault's public sitemap, search index or link listing.
  3. Enforce a role ceiling on the server: no grant may exceed the member's vault role. Acceptance: a viewer token that requests PUT, DELETE, join or ops on a shared vault receives 403, the attempt is recorded in the audit log without secrets, and a per-note grant can never widen a member's role beyond the role the owner assigned on the vault.
  4. Make the publish surface a filtered projection, not a mirror of the vault. Acceptance: publishing a folder emits only .md files that pass the include/exclude filters and have publish not set to false, publishes no binary attachment, and unpublishing returns 404 for every page of that folder within one minute.
  5. Add a durable per-note attribution view ("who changed what") driven by the OT op log. Acceptance: after two users edit the same note, selecting any region of text shows which user changed it and when, the answer survives a client restart, and the data is served by the server rather than reconstructed on the client.
  6. Add rate limiting and abuse protection to every anonymous route. Acceptance: an IP exceeding the configured share-link request budget receives 429 with Retry-After and X-RateLimit-Remaining, the limit is configurable per vault, and a request from an allow-listed IP is never throttled.
  7. Adopt a suggestion/comment channel stored inside the Markdown (CriticMarkup). Acceptance: an editor can propose a change that appears as a pending suggestion, the note on disk contains the suggestion as CriticMarkup, accepting or rejecting it rewrites the note through the normal OT path, and a note with no pending suggestions is byte-identical to a note edited without comments.
  8. Make offline rejoin explicit and observable: offline badge, pending-op count, and a one-click "rejoin with snapshot". Acceptance: editing a note while the server is unreachable shows "offline — N edits pending", and on reconnect the client either applies the queued ops transformed against the new revision or asks the user to accept a snapshot, never silently discarding a pending edit.
  9. Generate a static search index and a theme file for published vaults, from the published set only. Acceptance: a published folder has a working client-side search that returns only published pages, a dark/light theme switch driven by prefers-color-scheme, and no unpublished note title appears anywhere in the emitted HTML, the search index, the sitemap or the RSS feed.
  10. Publish the site on the owner's own domain and strip author metadata by default. Acceptance: the published site is reachable at a hostname the owner controls with a valid TLS certificate served by the homelab, and the rendered HTML of a published note contains no author name, email or avatar unless the note explicitly opts in.

Risks

  • Absence claims are weak evidence. "Obsidian Publish has no version history", "Notion Sites has no comments", "HedgeDoc 2 has no publish feature" and "neither MkDocs nor Quartz supports multi-user editing" are inferences from documentation and tree scans, not official statements. They are marked [unverified] above and must be re-checked before they enter a spec.
  • Vendor pricing and tiers move. Relay's README and pricing page disagree on Starter limits and the Premium tier is missing from the README; Peerdraft's README, pricing page and changelog name three different tier sets and prices; Logseq's DB pricing is not rendered to a non-JavaScript client. Quote any price only with its access date, or quote none.
  • Neither Notion nor Google publishes its sync algorithm. Claims that Google Docs uses OT, or that Notion merges at block granularity, are [unverified]. NotesCraft's OT must be justified from its own properties and from HedgeDoc 1.x's published OT.js stack, never from vendor marketing.
  • Offset-unit mismatch is a silent-corruption class of bug. NotesCraft counts Unicode scalars; ot.js, ot-text and Y.Text count UTF-16 code units; only Loro matches scalars natively. Any interop with HedgeDoc 1.x, ShareDB or a Yjs client needs an explicit conversion at the wire boundary.
  • Licensing contamination. HedgeDoc is AGPL-3.0 and Outline is BSL 1.1. Both are fine to read and must never be copied into NotesCraft. Every library surveyed (yjs/yrs, automerge, loro, sharedb, ot-json0, ot-text) is MIT or ISC and safe to adopt.
  • Dependency churn if a CRDT is ever adopted. Automerge's npm latest is a 2.0.0-alpha with a published 2→3 migration guide, yrs/loro move fast, and HedgeDoc 2 itself is 2.0.0-alpha.3 whose API may change before release. Pin exact versions and re-verify before every bump.
  • Publishing leaks by default. Notion publishes contributor names, profile photos and email addresses in page metadata; Quartz emits all non-Markdown files publicly; Quartz's UnlistedPages still serves the HTML by URL; a shared cache in front of /p/... can serve an expired token's content unless responses are private, no-store. Publishing must default to anonymous, filter binaries, and separate the public route from the tokenised route.
  • A client-side password is not access control. Quartz's own words: "It protects against casual browsing but not against determined attackers". Expiry, revocation and throttling must be server-side.
  • Comment anchors rot. A comment anchored to a line number silently attaches to the wrong text after an edit. Anchor on a text quote (plus a hash of it) or on a transformed range, and never on a fixed offset.
  • "Anyone with the link" outruns "invite only". Both Relay and Peerdraft use share URLs; Relay admits that removing someone does not stop them rejoining. NotesCraft's invite codes are hashed, single-use and 48-hour limited — keep that, and do not ship a permanent share key as a shortcut.
  • Live editing is a server-availability feature, not a file feature. OT needs the server online for the live path; with the homelab down, collaboration degrades to file sync plus merge3. Say so in the UI rather than failing silently.
  • E2EE vaults cannot have live sessions. The server must read operations to order them, so E2EE vaults keep file sync only (already in the spec). Anytype avoids the conflict by making the object graph — not the file — the truth; Standard Notes avoids it by refusing collaboration entirely. NotesCraft's position (server-readable vaults, explicit opt-in E2EE) is defensible but must be stated, not implied.
  • Scope creep is the real risk. Comments, suggestions, publishing, mentions, share links and live collaboration are six separate products; each vendor spends a whole help-centre section on one. specs/collaboration/spec.md deliberately put comments and public pages at P2 — this research does not overturn that, it prices it.

Sources

All URLs accessed 2026 (research date 2026-10-20). Official vendor documentation, official pricing pages and official repositories unless labelled otherwise. Local grounding: SPEC.md, specs/collaboration/spec.md, specs/capture-and-publish/spec.md, specs/mobile-and-sync/research/sync-landscape.md, crates/collab/**, apps/notescraft-sync-server/src/roles.rs.

Obsidian — Sync, Publish, plugins

Obsidian community collaboration plugins

Apple Notes / iCloud

Anytype

Notion

Google Docs / Drive

Logseq

Standard Notes

HedgeDoc

Outline

CRDT / OT libraries

Publishing to the web