Open Editor

A framework-independent, production-grade rich text editor built in pure JavaScript. Zero dependencies. Runs forever. You own every line.

Philosophy

Zero dependencies — no npm packages in core, ever. Ships in 2025, still works in 2035.
Modular — every feature is a plugin. Use only what you need.
You own the DOM — no contenteditable surprises. The editor controls its own document.
Framework agnostic — works with React, Vue, Angular via thin wrappers. Core never changes.
Premium-ready — free core, licensed premium features, clean separation.

Quickstart

Status: 1.1.0 — ships as openeditor-text (npm install openeditor-text, or npx openeditors add text), part of the openeditors family (Phase 25 naming decision; the earlier @open-editor-hq/core name is deprecated with a pointer). The API below is frozen and contract-tested; post-1.0.0 features land additively in 1.x.

import { OpenEditor } from 'openeditor-text';

// 1. Construct on any element (selector string or HTMLElement).
const editor = new OpenEditor('#app', {
  placeholder: 'Start typing…',
  theme: 'light',            // 'light' | 'dark' | 'minimal' | 'auto'
});

// 2. That's it — the toolbar, chrome, and all styling are injected by the
//    editor itself. No CSS file to import.

// 3. Read / write content.
editor.setHTML('<p>Hello <strong>world</strong></p>');
const html = editor.getHTML();          // sanitized HTML out
const md   = editor.getMarkdown();      // GitHub-flavored Markdown out (1.1.0)
editor.on('onChange', ({ html }) => save(html));

Optional plugins are opt-in via factories (tree-shakeable — you only ship what you install):

import { OpenEditor, createImagePlugin, createLinkPlugin, createTablePlugin } from 'openeditor-text';

const editor = new OpenEditor('#app');
editor.plugins.install(createImagePlugin());
editor.plugins.install(createLinkPlugin());
editor.plugins.install(createTablePlugin());
// …createMediaPlugin, createEmojiPlugin, createFindReplacePlugin,
//    createCodeBlockPlugin, createSourcePlugin, createPreviewPlugin, etc.

Configuration → docs/CONFIG.md · Theming → docs/THEMING.md · Error reporting → docs/ERROR-REPORTING.md · Security → SECURITY.md

Architecture

Design model: DOM-first. The contenteditable DOM is the single source of truth for document content. There is no separate in-memory document model that the DOM mirrors — the editor reads the DOM directly (getHTML() returns the live DOM), and structure is kept correct by a central Normalizer that cleans the browser's messy output into a known Canonical DOM Shape (see the "Canonical DOM Shape" section). The STATE MANAGER tracks only flags and metadata (dirty flag, read-only, counts) — never content. This is the Jodit / TinyMCE approach, chosen deliberately: it is the only architecture that a pure, zero-dependency, single-maintainer project can ship and harden incrementally. (A model-first design like ProseMirror / CKEditor 5 buys cleaner complex operations and collaboration, but costs a full parser + renderer + input interception engine before a single feature ships — the wrong trade here.)

getJSON() / setJSON() are a serialization convenience for storage, NOT an internal model — the editor never edits through them.

USER INPUT
    ↓
TOOLBAR / MENUS / STATUS BAR
    ↓
PUBLIC API  (editor.getHTML / editor.commands.execute / editor.on)
    ↓
COMMAND MANAGER  (bold, italic, heading, list, insert...)
    ↓
PLUGIN MANAGER  (image, link, table, code, emoji, media...)
    ↓
SELECTION ENGINE  (cursor, ranges, save/restore, cross-browser)
    ↓
HISTORY ENGINE  (undo/redo, full-HTML snapshots)
    ↓
STATE MANAGER  (flags + metadata only — dirty, read-only, counts; NOT content)
    ↓
NORMALIZER  (cleans browser DOM → Canonical DOM Shape; runs after input + paste)
    ↓
DOM  (contenteditable — the source of truth; event capture)

SHARED UI LAYER  (modal system, tooltip system, context menu system)

PREMIUM LAYER (separate, license-gated)
    License Key → Feature Manager → SEO / Export / AI / Collaboration
    (Collaboration builds a lightweight model DERIVED from the DOM — the one
     place a model is needed, isolated to where it pays for itself.)

Canonical DOM Shape

Because the editor is DOM-first, the DOM is the model — so the editor only stays consistent if every command, paste, and normalization pass produces the same known structure. This section is that contract: the canonical shape the Normalizer enforces and every command must obey. It is the DOM-first substitute for a schema. If two operations can produce different DOM for the same visual result, this document decides which one wins.

Top level

The editable root contains only block elements — never loose text nodes. Bare text typed at the root is wrapped in  (force-paragraph mode).
Allowed top-level blocks: p, h1–h6, blockquote, pre, ul, ol, dl, table, figure, hr, and plugin block islands (contenteditable="false" wrappers).

Empty states

An empty editor is a single   — never a bare  , never empty.
An empty block (paragraph the user cleared) is  ; the   is a placeholder so the caret has somewhere to sit. It is stripped on serialization output where a block has other content.
A pending-format wrapper (empty  created by toggling bold on a collapsed caret) holds a single ZWSP so the caret can enter it; the ZWSP is stripped by getHTML() and never survives serialization.

Inline formatting

Canonical tags:  (not ),  (not ), , <s> (not <strike>/<del>), , , <code>, <a>.
Color, font, size, spacing, decoration → a single . Re-applying a property updates the existing span in place, never nests a second span. Toggling a partial selection splits the run (before/after stay wrapped, the selected part is unwrapped) — text is never reordered.
Inline elements never wrap block elements. Adjacent identical-format spans are merged. Empty inline elements are pruned.

Lists

ul/ol contain only li. A nested list lives inside an <li>, as a child of that li — never as a direct child of another list.
Outdenting an item splits the sublist so trailing siblings stay nested.

Blocks inside structure

Heading/paragraph commands are no-ops inside a list item (a list item is not reformatted to a heading; leave the list to apply a block format first).
Blockquote on a list item wraps the item's contents (<li><blockquote>…</blockquote></li>), never the <li> itself.

History & serialization

Undo/redo are full-HTML snapshots of the canonical DOM — no diffing, no operational model. Snapshots store the selection bookmark alongside the HTML.
getHTML() returns canonical, serialization-safe HTML (placeholders/ZWSP stripped). getJSON()/setJSON() round-trip that HTML — they are storage convenience, not an internal model.

Every milestone's "clean output" is judged against this shape. A snapshot-test suite (sequence of operations → assert exact getHTML()) is the primary mechanism that keeps the canonical shape from drifting.

Folder Structure

Note: the tree below is the original aspirational layout and is partly out of date. The shipped reality: everything lives under packages/core/src/ as a single package — there is no separate toolbar/ or standalone ui/ package. Toolbar, status bar, and shared UI are in packages/core/src/ui/; plugins in packages/core/src/plugins/; the paste engine in packages/core/src/paste/; the sanitizer in packages/core/src/sanitizer/. The normalizer.js shown as "planned" was instead realized as _ensureParagraphMode (in editor-dom.js) plus utils/html-normalize.js. Treat the annotations inside the tree as historical.

open-editor/
├── packages/
│   ├── core/                      ← engine (pure JS, zero deps)
│   │   ├── src/
│   │   │   ├── editor.js          ← OpenEditor bootstrap class
│   │   │   ├── editor-api.js      ← public API methods (mixin, keeps editor.js ≤300 lines)
│   │   │   ├── editor-events.js   ← DOM/lifecycle event wiring (mixin)
│   │   │   ├── editor-maxlength.js← maxLength enforcement helpers (mixin)
│   │   │   ├── editor-config.js   ← config DEFAULTS + prototype-safe deep merge
│   │   │   ├── index.js           ← package entry point
│   │   │   ├── version.js
│   │   │   ├── events/
│   │   │   │   └── event-emitter.js
│   │   │   ├── state/
│   │   │   │   └── editor-state.js
│   │   │   ├── selection/
│   │   │   │   ├── selection-manager.js
│   │   │   │   └── range-utils.js
│   │   │   ├── commands/
│   │   │   │   ├── command-manager.js
│   │   │   │   ├── setup-commands.js   ← registers built-in commands + shortcuts
│   │   │   │   ├── text-commands.js
│   │   │   │   ├── inline-unwrap.js    ← partial-selection split/unwrap (DOM surgery)
│   │   │   │   ├── block-commands.js
│   │   │   │   ├── list-commands.js    ← (+ list-dom.js, list-dom-indent.js, list-keyboard.js)
│   │   │   │   ├── style-commands.js   ← typography / decoration commands
│   │   │   │   ├── color-commands.js   ← text/background color + clear
│   │   │   │   └── normalizer.js       ← (planned) enforces Canonical DOM Shape after input/paste
│   │   │   ├── history/
│   │   │   │   └── history-manager.js
│   │   │   ├── sanitizer/
│   │   │   │   ├── sanitizer.js        ← tag/attr whitelist, URL/CSS guards, mXSS pass
│   │   │   │   └── sanitizer-utils.js  ← encoding/text/structure + URL/CSS safety helpers
│   │   │   ├── shortcuts/
│   │   │   │   └── shortcut-manager.js
│   │   │   ├── logger/
│   │   │   │   └── logger.js
│   │   │   ├── ui/                     ← shared UI primitives (Phase 6, lives in core)
│   │   │   │   ├── modal-manager.js
│   │   │   │   ├── tooltip-manager.js
│   │   │   │   ├── context-menu-manager.js
│   │   │   │   ├── focus-trap.js
│   │   │   │   └── ui-styles.js
│   │   │   └── utils/
│   │   │       ├── base-css.js
│   │   │       ├── clipboard.js
│   │   │       ├── debounce.js
│   │   │       └── html-normalize.js
│   │   ├── tests/                 ← Vitest unit + jsdom integration tests
│   │   └── package.json
│   │
│   │   # NOTE: There is NO parser/ or renderer/ — the editor is DOM-first, so
│   │   # the DOM is the model. Structure is enforced by commands/normalizer.js
│   │   # (the Normalizer) against the Canonical DOM Shape, not by a model layer.
│   │   # plugins/plugin-manager.js is planned (Phase 8+) and not yet implemented.
│   │   # The toolbar/ and a standalone ui/ package below are planned (Phase 7);
│   │   # Phase 6 UI currently ships inside core/src/ui/.
│   │
│   ├── toolbar/                   ← (planned, Phase 7) toolbar + status bar UI
│   │   ├── src/
│   │   │   ├── toolbar.js
│   │   │   ├── button.js
│   │   │   ├── dropdown.js
│   │   │   ├── color-picker.js
│   │   │   ├── status-bar.js
│   │   │   ├── inline-toolbar.js
│   │   │   └── menu.js
│   │   └── package.json
│   │
│   ├── plugins/                   ← official plugins
│   │   ├── image/
│   │   ├── link/
│   │   ├── table/
│   │   ├── code/
│   │   ├── emoji/
│   │   ├── media/
│   │   ├── special-chars/
│   │   ├── find-replace/
│   │   ├── source-code/
│   │   └── paste-engine/
│   │
│   ├── themes/                    ← CSS only, no JS
│   │   ├── default/
│   │   ├── dark/
│   │   └── minimal/
│   │
│   ├── premium/                   ← license-gated features
│   │   ├── seo/
│   │   ├── export/
│   │   ├── ai/
│   │   ├── collaboration/
│   │   └── mentions/
│   │
│   └── wrappers/                  ← framework adapters
│       ├── react/
│       ├── vue/
│       └── angular/
│
├── apps/
│   ├── playground/                ← dev sandbox (Vite)
│   └── docs/                      ← documentation site
│
├── examples/
│   ├── basic/
│   ├── with-react/
│   └── full-featured/
│
├── pnpm-workspace.yaml
├── package.json
└── README.md

Status

CURRENT REALITY (updated 2026-07-31) — read this first. The phase-by-phase log below is historical and parts were written before the commercial platform was built. Where an item still reads "planned/[ ]" but is actually shipped, the status has been corrected inline. Today's true state:

Free editor — complete; speech dictation added (free, browser Web Speech API).

Premium (Phase 19) — Export PDF + Export DOCX are built and the only features sold. SEO and AI were built, then deliberately DEPRECATED + made un-sellable (product decision — no-SEO/no-AI launch; code retained, not deleted). Comments / Track-Changes / Collaboration / Version-History etc. remain unbuilt.

Commercial platform (Phases 22–24) — built and working: ES256 licensing engine, admin panel (sidebar + overview + package/customer/license/order/roles/users), RBAC, Stripe one-time checkout with domain-bound auto-issuance, magic-link customer portal, silent-refresh renewal, anti-sharing soft-flag, lifecycle emails.

Genuinely NOT built: self-serve trials (24.3), admin 2FA + append-only audit log (23.4), Phase-20 "moats" (perf benchmarks, crop/rotate, file manager…).

Operational (not code): rotate the backend .env secrets, put the backend under git, and add Terms/Privacy/Refund pages before taking real customers.

Phases 0–16.7 (incl. 4.5 and 7.5) are implemented and verified — the editor is feature-complete through Accessibility & Mobile (14), the Theme System (15), the frozen Public API (16, 1.0.0-rc.1), Production Hardening (16.5), Modern Editing UX (16.6), and the Competitive Parity Pass (16.7). Phase 13 (Content Plugins) adds 11 plugins — Source Code view (zero-dep, XSS-verified round-trip), Find & Replace (CSS Custom Highlight API), Special Characters, Emoji, Media Embed (sandboxed provider iframes, 72-probe XSS-verified), Horizontal Rule, Code Block, Resizable Editor, Format Painter, Spellcheck, and Preview — with Emoji, dedicated Code Block, and sandboxed Media Embed going beyond standard Jodit. Phase 12 (Paste Engine) is complete — staged cleanup pipeline, ask-on-paste dialog, Ctrl+Shift+V, context-aware insertion — also beyond Jodit in several respects. Phase 11 (Table) is complete on a formal-matrix model. The core package has 2060 passing unit tests (Vitest + jsdom, 166 files) and the playground has e2e tests passing across Chromium, Firefox, and WebKit, including a public-API freeze contract test, a 100-cycle memory-leak test, and performance-budget gates. The React (7), Vue (5), Angular (9), CLI (14), and entitlements (39) packages have their own suites, now all run in CI (previously core-only — fixed 2026-07-16). Every .js source file is within the 300-line limit (the one 305-line file, image-styles.js, is CSS-in-JS, which the limit exempts). Known cross-browser coverage gap: clipboard/paste e2e is skipped on Firefox (13 tests) — synthetic paste events are unreachable in headless Firefox; the paths are covered on Chromium + WebKit.

Phase 4.5 (block editing semantics) is fully shipped: Enter-split, Backspace/Delete-merge, structural conversions, multi-block delete, contenteditable="false" island handling, editor floor, and block indent/outdent.

Phase 7.5 (Playwright Verification Gate) moved the bulk of the jsdom-only tests into real browsers. Phase 14 (Accessibility & Mobile) then hardened the remaining gaps: mobile tap targets are now 44×44px (e2e asserts it), the editable has a visible focus ring, the color picker is fully keyboard-operable, RTL/bidi and high-contrast/reduced-motion are supported, and long-press/touch behaviours are wired. 7.18 (sticky-on-scroll rigorous verification) remains the one [~] deferred to on-device testing.

Phase 9 (Image Plugin) is fully shipped: insert by URL or file upload, drag-and-drop, clipboard paste, click-to-select, corner-handle resize with Shift-locked aspect ratio, four alignment modes, alt/title/link via context menu, <figure>/<figcaption> semantic structure, loading="lazy" by default, and contenteditable="false" island contract for all future embedded content plugins.

Phase 9.1 (Image Properties) adds a Jodit-style properties dialog opened by double-click or the context menu / action bar: edit source, alt, title, width/height with lock-aspect, alignment, border-radius, and per-side margins (with lock), plus a Delete action. Phase 9.4 adds a floating quick-action bar on a selected image (align left/center/right, edit, link, delete) so common actions don't require right-click. Sizing/border-radius/margins are written as inline style on the <img> (already allowed by the sanitizer and guarded by isUnsafeStyle); alignment stays on the <figure>.

Phase 9.2 (Advanced) adds an Advanced group to the properties dialog — CSS class (a multi-select when imageAvailableClasses is configured, else free text), id, and an inline-style field (managed properties are hidden from it so they can't be clobbered). Phase 9.3 adds config: imageDefaultWidth (applied to inserted images that carry no size), imageAvailableClasses, and imageOpenOnDblClick. Phase 9.5 polish: a decorative-alt accessibility nudge in the dialog, a plugin:image:loaderror event when an inserted image fails to load (for host toasts), and a clearer caption affordance on selected images. The crop/rotate image editor remains a deliberately separate future phase.

Phase 8 (Plugin System) is complete: PluginManager with register/install/uninstall/get/getAll, full plugin lifecycle hooks via EventEmitter, automatic listener cleanup, dependency resolution with circular detection, plugin error isolation, toolbar button contribution, and the createTestEditor test harness.

Phase 10 (Link Plugin) is fully shipped: Ctrl/Cmd+K dialog, toolbar button, wrap-selection (block-safe), custom inline popover (open/edit/unlink) on existing links, edit href + text, unlink, paste-autolink, href whitelist (isAllowedLinkHref), rel noopener/nofollow handling, CSS class + aria-label fields, dbl-click-open and readonly-nav-guard behaviors. Video→iframe embeds (processVideoLink) were intentionally deferred to Phase 13 to keep the iframe security surface out of the link phase, and are now delivered there (Media Embed plugin).

Implemented vs. Planned

Built and verified (Phases 0–13, 4.5, 7.5): core engine, state, selection, command system, block-editing semantics, history/undo-redo, shared UI (modal/tooltip/context-menu), state-aware toolbar with dropdowns + custom canvas color picker, inline bubble toolbar, status bar, i18n, fullscreen, print, sanitizer (security-hardened), plugin system, image plugin (insert/upload/drag-drop/paste, resize, properties dialog, action bar), link plugin (dialog, popover, autolink, color), table plugin (formal-matrix model), paste engine (Word/Google-Docs cleanup, ask-on-paste, context-aware insertion), and the 11 content plugins below.

Content plugin (Phase 13)	Status
Source-code (HTML) view — XSS-verified round-trip	built
Find & Replace — CSS Custom Highlight API	built
Video / iframe embed (YouTube / Vimeo) — sandboxed, `processVideoLink`	built
Special characters + Emoji inserter	built
Format painter (copy formatting)	built
Horizontal rule	built
Code block	built
Resizable editor	built
Spellcheck toggle	built
Preview	built

Planned but NOT yet built (Phases 15–19): documented as milestone plans below, not shipped code. Everything in this list is a gap versus a full Jodit-class editor:

Roadmap item	Phase	Status
Accessibility & Mobile (ARIA depth, full keyboard nav incl. color picker, touch targets, RTL/bidi, high-contrast, reduced-motion)	14	built
Theme System (CSS custom properties, dark/minimal/auto themes, runtime switch, CSP-safe injection)	15	✅ done
Public API (frozen surface, contract test, config validation)	16	✅ done (`1.0.0-rc.1`)
Production hardening (perf throttle + CI gates, dirty guard, crash recovery, leak test)	16.5	✅ done
Modern Editing UX (slash-commands, markdown autoformat, @mentions, block drag-reorder)	16.6	✅ done
Competitive Parity Pass (list style auto-progression, typed-URL autolink, to-do lists, F&R whole-word, table properties split, table header-click selection, source syntax highlighting, responsive images, selection word count)	16.7	✅ done
npm Publishing (ships as `@open-editor-hq/core` — rc.1 LIVE on `next`; minified-only distribution; ESM/CJS/UMD, `types` export, size-gated, WCAG conformance statement, plugin guide, 4 locale packs)	17	✅ done — 1.0.0 LIVE on npm (2026-07-14)
Free-Tier Competitive Sweep (autocorrect, change case, bookmarks, page break, show blocks, a11y help dialog, `:` emoji autocomplete, styles dropdown, sanitizer allowlist config, type-around, text-part language, Markdown export)	17.5	✅ 12/12 core done (2026-07-14) — ships as 1.1.0; 2 stretch items deferred
Framework wrappers (React / Vue / Angular — all three live-proven caret-stable from packed tarballs)	18	✅ done (2026-07-14)
Premium layer (license + Export PDF/DOCX shipped & sold; SEO/AI built then deprecated + un-sellable by product decision 2026-07-31; Collaboration/Comments/Track-Changes/Version-History + document-app plugins remain unbuilt)	19	🟡 partial — PDF/DOCX export live & sold; SEO/AI intentionally disabled; the rest unbuilt
Engineering Moats (large-doc perf benchmarks, Android IME hardening, offline-first autosave, Excel paste cleanup, image crop/rotate, file manager)	20	planned (parallel, non-blocking)
Web Platform 1: Public Site + Playground (fresh `open-editor-web` project — Next.js; landing, live demo with config reflector, docs, comparison)	21	✅ built (2026-07-15) — deploy/hosting/domain deliberately deferred to project completion
Entitlements Foundation (feature registry, offline ES256 licenses, FeatureManager, dev issuer + adversarial sweep)	22	✅ done — incl. 22.5 anti-sharing (persisted fetch-log → soft-flag → human-confirmed revoke)
Web Platform 2: Admin Panel + License Service (same repo, behind auth: two-pipe package matrix — config profiles for core features + signed licenses for premium; roles, audit, full admin control)	23	✅ built — full admin panel (sidebar + overview + 6 panels), license engine (ES256 signer), RBAC roles/users, order admin
Web Platform 3: Commerce & Customer Portal (same repo: self-serve buy/renew, billing, trials)	24	🟡 mostly built — Stripe checkout + auto license issuance + magic-link portal + silent-refresh renewal + lifecycle emails all live; trials (24.3) NOT built; portal-side invoices deferred (Stripe sends receipts)

Serial execution order (revised 2026-07-14 with the commercial-platform proposal): 18 (wrappers, React first) → 21 (website + playground) → 22 (entitlements foundation) → 19 wave 1 (Export PDF/DOCX + Word Import + Version History, licensed via 22's dev issuer) → 23 (license platform + admin panel) → 19 wave 2 (Comments → Track Changes → Collaboration) → 24 (commerce) — with 20 (moats) running parallel and non-blocking throughout. Rationale: adoption surfaces first (18, 21); the entitlement contract (22) before any premium code so 19 is gated from day one; the admin platform (23) once there's something to sell; commerce (24) once there's someone to sell to. Phase 17 is the hard gate — nothing in 17.5+ starts until npm install @open-editor-hq/core works. (Both are done — 1.0.0 is live; the 17.5 sweep ships as 1.1.0.) (Accessibility & Mobile (14), Theme System (15), Public API freeze (16), Production Hardening (16.5), and Modern Editing UX (16.6) are all complete). A full re-audit against CKEditor/Jodit (2026-07) found Phases 0–16.6 genuinely solid with only cosmetic doc drift — but surfaced concrete, verified feature gaps (16.7) worth closing before publishing, so the free-tier feature set is at its strongest when it ships.

Development Phases

Every phase has a defined goal, output, and test. Phase N must be complete and clean before Phase N+1 starts.

Two phases use decimal numbering (4.5, 7.5) so they slot into the existing sequence without renumbering everything after them — they are full phases with the same gate discipline, not optional add-ons.

PHASE 0 — Project Foundation

Goal: Monorepo running, dev environment working, build pipeline verified.

Milestones:

0.1 — pnpm workspace initialized, all package.json files in place
0.2 — Rollup configured for core package (ESM + CJS + UMD output)
0.3 — Vite playground running, hot reload working
0.4 — Vitest configured and a passing dummy test exists
0.5 — Playwright configured with a passing browser smoke test

Clean output: pnpm dev opens playground at localhost. pnpm test passes.

PHASE 1 — Core Engine

Goal: The editor mounts on a DOM element, owns its container, fires lifecycle events.

Milestones:

Clean output: new OpenEditor('#target', config) renders editor with placeholder. editor.destroy() cleans up with zero leaks. toolbar: false produces a bare contenteditable with no toolbar DOM.

PHASE 2 — State Manager

Goal: A single source of truth for document state — dirty flag, metadata, and read-only mode — so every part of the editor reads the same document status.

Milestones:

2.1 — EditorState: holds content, isDirty, isReadOnly, metadata (title, author, wordCount)
2.2 — isDirty set to true on every input event; reset to false on setHTML() or explicit markClean()
2.3 — isReadOnly toggle: setReadOnly(true/false) — disables contenteditable, dims toolbar buttons
2.4 — onChange fires on content change, debounced (default 300ms, configurable) — coalesces a burst of keystrokes into one event; suppressed during setHTML() and IME composition
2.5 — metadata object updated via editor.state.setMeta(key, value), read via editor.state.getMeta(key)
2.6 — editor.state.wordCount / charCount updated live via MutationObserver (reuses observer from Phase 1)
2.7 — editor.state.serialize() / deserialize(snapshot): JSON round-trip of content + metadata (used by autosave plugins)
2.8 — State changes emit events via Phase 1 EventEmitter (stateChange, readOnlyChange)

Clean output: editor.state.isDirty is true after typing. setReadOnly(true) prevents all input. onChange fires once per dirty transition, not per keystroke.

PHASE 3 — Selection Engine

Goal: A reliable, cross-browser selection and range abstraction that every command depends on.

Milestones:

Clean output: editor.selection.save() returns a bookmark; editor.selection.restore(bookmark) puts the cursor back in the exact same position after DOM changes. All commands use SelectionManager exclusively — zero direct window.getSelection() calls outside selection layer.

PHASE 4 — Command System

Goal: All editing actions go through a unified, testable command interface.

Milestones:

Clean output: Every formatting operation works via editor.commands.execute('bold'). No direct DOM calls outside commands. Batch operations produce one undo step. Custom commands register and work identically to built-ins.

PHASE 4.5 — Block Editing Semantics

Goal: Correct, cross-browser behavior for the structural edits that contenteditable handles badly on its own — merging, splitting, and deleting across block boundaries. This is the hardest core engine work and the dividing line between a toy and an advanced editor; it gets its own phase instead of being scattered as one-off keydown patches. Everything here produces the Canonical DOM Shape.

Milestones:

Clean output: Enter/Backspace/Delete behave identically across Chrome, Firefox, and Safari for every block combination. No keystroke ever produces invalid HTML or loses formatting on the unselected side of a merge.

PHASE 5 — History Engine

Goal: Undo/redo that works correctly and never loses content.

Milestones:

5.1 — HistoryManager: snapshot stack, index pointer
5.2 — Snapshot taken on: Enter key, command execute, paste, IME commit, 1.5s idle after typing (consecutive identical snapshots de-duplicated; a no-net-change snapshot after an undo still discards the stale redo branch)
5.3 — undo() restores previous snapshot + selection position
5.4 — redo() moves forward in stack
5.5 — canUndo() / canRedo() boolean methods
5.6 — Browser native Ctrl+Z / Cmd+Z intercepted (shortcut handler preventDefaults) and replaced with our own
5.7 — Max 100 snapshots, oldest dropped when limit hit
5.8 — Selection position saved in snapshot, restored on undo

Clean output: Ctrl+Z / Ctrl+Y works correctly for all command types. Rapid typing collapses into one undo step.

PHASE 6 — Shared UI System

Goal: Reusable modal, tooltip, and context menu primitives that every plugin uses — built once, never duplicated.

Milestones:

6.1 — ModalManager: open(config), close(), stack support (modal on top of modal)
6.2 — Modal features: title, body (HTML or DOM node), footer buttons, close on Escape, close on backdrop click
6.3 — Focus trap inside open modal: Tab cycles within modal only, re-asserts if focus escapes; returns focus to the triggering element on close (WCAG 2.1 / 2.4.3)
6.4 — Modal returns a Promise that resolves with the user's action (confirm/cancel/value)
6.5 — TooltipManager: show(element, text), hide(), auto-positions above/below/left/right, never off-screen; preserves any pre-existing aria-describedby
6.6 — ContextMenuManager: show(x, y, items[]), hide(), keyboard navigation (arrow keys, Enter, Escape) including into and out of sub-menus
6.7 — Context menu items support: label, icon, shortcut hint, separator, disabled state, sub-menu
6.8 — All three systems are scoped to editor container (no document-level pollution)
6.9 — All three systems are keyboard navigable and screen-reader accessible (ARIA roles, aria-activedescendant roving focus, role="dialog"/menu/tooltip)

Clean output: A plugin can call editor.ui.modal.open(...) and get a clean dialog. No plugin ever builds its own modal from scratch.

PHASE 7 — Toolbar System

Goal: A fully functional, state-aware toolbar built in pure JS DOM.

Milestones:

Clean output: Toolbar renders, bold button highlights when cursor is in bold text, dropdowns open/close, color picker applies colors, fullscreen + print work, status bar updates live, all strings overridable. All .js source files ≤300 lines (the sole 305-line file is image-styles.js, CSS-in-JS, which the limit exempts). Pixel-level positioning (dropdown flip, bubble anchoring, sticky, mobile touch) needs Playwright verification. [~] = shipped-but-needs-browser-verification.

PHASE 7.5 — Playwright Verification Gate

Goal: Prove the foundation (phases 0–7 + 4.5) actually works in real browsers before a single plugin is built on top of it. jsdom has already let real bugs ship (text-reordering on partial toggle, the color-nesting bug) — it cannot model selection, focus, caret position, or layout. This gate converts every [~] marker into a [x] backed by a real-browser test, and is a hard blocker: Phase 8 does not start until this is green.

Milestones:

7.5.1 — Playwright runs the suite against Chromium, Firefox, and WebKit (the three engines behind all six target browsers), wired into CI.
7.5.2 — Selection & caret verified live: save/restore across DOM mutation, RTL selection normalization, double-click word selection, partial-toggle split (clears the 3.9 [~]).
7.5.3 — Block editing (Phase 4.5) re-run in all three engines — caret-dependent merges/splits confirmed identical.
7.5.4 — Toolbar pixel behavior: dropdown off-screen flip (7.3), inline bubble anchoring (7.19), sticky-on-scroll (7.18), mobile overflow + touch targets (7.21) — all [~] cleared.
7.5.5 — Clipboard paths that jsdom can't run: copy/cut/paste, permission fallbacks, plain-text fallback.
7.5.6 — Undo/redo with real keystrokes and real selection restoration.
7.5.7 — Accessibility smoke pass with axe-core rules: ARIA roles, focus rings, keyboard-only toolbar traversal.
7.5.8 — Snapshot regression suite (operation sequence → exact getHTML()) runs in real browsers as the standing guard against canonical-shape drift.
7.5.9 — A documented "no [~] left in phases 0–7" checklist — the gate is only passed when zero shipped-but-unverified markers remain.

Clean output: Every phase 0–7 + 4.5 feature has a passing real-browser test in all three engines. No [~] markers remain. CI fails if any cross-browser test fails. Only now does plugin work begin.

PHASE 8 — Plugin System

Goal: Any feature can be added or removed without touching core.

Milestones:

Clean output: A demo plugin installs, adds a toolbar button, handles a keystroke, uninstalls cleanly.

PHASE 9 — Image Plugin

Goal: Insert, upload, resize, align images inside the editor.

Milestones:

Clean output: Full image workflow from upload to resize to alignment works. Clipboard paste image works.

PHASE 10 — Link Plugin

Goal: Create, edit, open and remove hyperlinks.

Milestones:

Clean output: Full link CRUD workflow. Custom inline popover appears on existing links. Paste-autolink, href whitelist, and Jodit-parity dialog/behaviors.

PHASE 11 — Table Plugin

Goal: Insert and edit HTML tables with full keyboard navigation.

Foundation & safety (added after Jodit-parity review):

11.0 — Formal-matrix model (table-matrix.js): a pure 2D grid built from a <table> that accounts for colspan/rowspan — a spanned cell appears in every grid position it covers. Maps cell↔(row,col) and computes selection bounds. Every structural operation (add/remove row-col, merge, split) is expressed against this matrix, and it normalizes away redundant span=1 attributes. Built and exhaustively unit-tested with zero UI before any DOM mutation — this is the bedrock that keeps colspan/rowspan bookkeeping correct.

11.19 — Cell key-guard: td/th are block elements, so the Phase 4.5 Enter-split / Backspace-merge logic would otherwise treat a cell as a block and corrupt the table (creating a sibling <td> outside a <tr>, merging cells, etc.). The plugin intercepts Enter/Backspace/Delete/Tab via onKeyDown (which runs before block-editing) whenever the caret is inside a cell, so cell editing never triggers structure-breaking block operations.

Sanitizer widening: <caption> and <colgroup>/<col> (for column widths) are added to the tag allowlist (guarded like all other tags), since the current allowlist strips them.

Milestones:

Clean output: Tables insert, navigate with keyboard, rows/columns add and remove correctly, ranges of cells can be selected and operated on together.

PHASE 12 — Paste Engine

Goal: Paste from any source (Word, Google Docs, browser) produces clean HTML.

Reuses the Phase 0–2 sanitizer — does NOT build a second one. The security sanitizer (tag/attr whitelist, URL/CSS guards, mXSS pass) already exists and runs on every paste. This phase adds source-specific cleanup (Word/GDocs garbage, list reconstruction, span merging) that runs after the security sanitizer, then normalizes the result into the Canonical DOM Shape.

Already in place (reused, not rebuilt): editor-paste.js (_onPaste) intercepts every paste, reads text/html (falling back to text/plain), runs it through the security sanitizer, escapes plain text with \n→ , enforces maxLength, and emits a cancelable paste event (already used by image-paste and lone-URL autolink). The sanitizer is a security filter, not a cleanliness filter — it allows style/class on most tags, so Word/GDocs garbage (mso-*, class="MsoNormal", empty/style-only spans, docs-internal-guid-…, fake list bullets) survives it. That garbage is exactly what this phase removes.

Milestones:

New milestones (Jodit parity + beyond — from a source-verified gap analysis against github.com/xdan/jodit):

12.12 — "Ask on paste" dialog — Jodit's signature paste behavior. On a rich-HTML paste, prompt Keep / Insert as Text / Insert only Text (Word variant labels the middle option "Clean"). Config: askBeforePasteHTML (default true), askBeforePasteFromWord (default true), defaultActionOnPaste (default 'keep'), defaultActionOnPasteFromWord (default null → falls back to defaultActionOnPaste). The three action values are 'keep' (run the full clean pipeline, formatting preserved), 'text' (escaped text with line breaks, no HTML — the "Insert as Text"/"Clean" button), and 'only' (plain-text paragraphs, all formatting stripped). Set the ask* flags to false to paste silently using the default action. packages/core/src/paste/paste-dialog.js.
12.13 — Style → semantic-tag conversion (font-weight:bold|700→, font-style:italic→, text-decoration:line-through→<s>, underline→, vertical-align:super/sub→/; multiple formats nest). More advanced than Jodit, which never promotes style formatting on paste. Runs before 12.3. packages/core/src/paste/style-to-semantic.js.
12.14 — Paste pipeline events — paste/beforePaste (cancelable entry; a listener may preventDefault()) then afterPaste after insertion. Existing plugins (image paste, lone-URL autolink) hook paste. packages/core/src/editor-paste.js.
12.15 — Context-aware paste — block-level paste at an inline caret splits the host block (no invalid -in-); <td>/<th>/<li> are not split open (content inserted inside them). packages/core/src/paste/paste-insert.js.
12.16 — RTF-only clipboard: documented decision — text/rtf is intentionally not decoded, so an RTF-only clipboard degrades to plain text (matches Jodit). RTF decoding + \pict image extraction is deferred to a later phase (documented in editor-paste.js, not silently dropped).

Test strategy: a fixture corpus of realistic Microsoft Word and Google Docs paste HTML (packages/core/tests/fixtures/paste-fixtures.js) asserted against expected clean output, per-source unit tests for every cleanup step, and apps/playground/tests/paste-engine.test.js covering the ask-on-paste dialog, Keep/Clean/plain actions, Word list reconstruction, and Ctrl+Shift+V across Chromium + WebKit (Firefox headless skips synthetic paste events, matching the existing clipboard suite).

Clean output: Paste from Word produces clean semantic HTML. No MSO garbage survives, style-driven formatting is preserved as //<s>/, and the user can choose Keep / Clean / plain-text per paste.

PHASE 13 — Content Plugins

Goal: Complete the standard plugin set to Jodit feature parity.

Milestones:

Deferred to a later phase (explicit scope decision): AI assistant + speech-to-text (need external services), class-span, xpath breadcrumb, add-new-line bar. fullscreen/print/inline-popup/char-word counter/Word-paste cleaning/line-height/sticky toolbar are already shipped in earlier phases.

Clean output: All 11 plugins install and work independently, every source file ≤300 lines, zero dependencies. Source view round-trips correctly (incl. byte-exact <pre>); Format painter paints across selections without nesting; Media Embed is XSS-verified. Emoji, dedicated Code Block, and sandboxed Media Embed go beyond standard Jodit.

PHASE 14 — Accessibility & Mobile

Goal: Editor is fully keyboard-navigable and works correctly on touch devices.

Pull foundational items forward. A few of these affect elements created in Phase 1 (the editable) and Phase 7 (the toolbar). Retrofitting them after 13 plugins exist means re-touching every plugin. Implement the foundational pieces in their home phase and only verify them here: 14.1 (ARIA on the editable) belongs in Phase 1; 14.6 / 14.10 (touch handling + 44×44px tap targets) belong in Phase 7. This phase then becomes the WCAG-AA + device verification pass over work already wired in, plus the genuinely mobile-specific items (virtual keyboard, long-press, pinch-zoom, RTL/bidi).

Milestones:

Shadow DOM (14.18): open-editor scopes its CSS with an .oe- class prefix on a global/iframe <style> tag. This does not pierce Shadow DOM boundaries — mounting the editor inside a shadow root leaves its styles in the outer document and the chrome will render unstyled. Shadow DOM is explicitly unsupported; mount the editor in the light DOM (or use iframe: true for isolation).

Clean output: Editor passes WCAG 2.1 AA for keyboard, focus, contrast, and motion; RTL/bidi and touch behaviours implemented and unit-tested. [~] = implemented, awaiting real-device (not just WebKit-emulated) confirmation.

PHASE 15 — Theme System

Goal: Fully skinnable editor with CSS custom properties.

Milestones:

Clean output: Theme switch at runtime with no flash. Zero global CSS side effects. Read-only looks different from enabled. ✅ Phase 15 complete — full tokenization: all 149 color literals across 14 style files migrated to semantic tokens, enforced by a no-color-literals guard test so dark mode can't silently break again. 15 unit tests (theme-system) + 4 (readonly) + 6 (inject-style) + 15 (tokenization guard); e2e proves each surface (empty editor, source view, char grid, callouts, read-only) actually reskins in dark, dark→light restores pixel-identically, and light stayed byte-identical through the migration. All 3 browsers.

📖 Guides: docs/THEMING.md (how to skin the editor) · docs/THEME-TOKENS.md (token system internals)

PHASE 16 — Public API

Goal: Clean, stable, documented API surface. Freeze it before npm publish.

// Content
editor.getHTML()                        // → string
editor.setHTML(html)                    // void
editor.getText()                        // → string
editor.getJSON()                        // → object (structured doc)
editor.setJSON(obj)                     // void
editor.isEmpty()                        // → boolean
editor.getWordCount()                   // → number
editor.getCharCount()                   // → number

// Editor state
editor.focus()
editor.blur()
editor.enable()
editor.disable()
editor.setReadOnly(bool)
editor.isReadOnly()                     // → boolean
editor.setTheme(name)                   // 'light' | 'dark' | 'minimal' | 'auto'
editor.getTheme()                       // → string
editor.setCSSVar(name, value)           // per-instance token override (guarded)
editor.getCSSVar(name)                  // → string (computed value)
editor.setDirection(dir)                // 'ltr' | 'rtl'
editor.getDirection()                   // → 'ltr' | 'rtl'
editor.toggleFullscreen()
editor.isFullscreen()                   // → boolean
editor.print()                          // opens the print dialog with editor content
editor.reset()                          // → boolean — re-render from the last clean snapshot (crash recovery)
editor.destroy()

// History
editor.undo()
editor.redo()
editor.canUndo()                        // → boolean
editor.canRedo()                        // → boolean

// Selection
editor.selection.get()                  // → SelectionInfo
editor.selection.save()                 // → bookmark
editor.selection.restore(bookmark)
editor.selection.getHTML()              // → string
editor.selection.getText()              // → string

// Commands
editor.commands.execute(name, ...args)
editor.commands.isActive(name)          // → boolean
editor.commands.isEnabled(name)         // → boolean
editor.commands.getAll()                // → Map<name, descriptor>
editor.commands.register(name, descriptor)

// Plugins
editor.plugins.install(plugin)
editor.plugins.uninstall(name)
editor.plugins.get(name)                // → plugin instance
editor.plugins.getAll()                 // → Map<name, instance>

// UI (shared primitives)
editor.ui.modal.open(config)            // → Promise<result>
editor.ui.modal.close()
editor.ui.tooltip.show(el, text)
editor.ui.tooltip.hide()
editor.ui.contextMenu.show(x, y, items)
editor.ui.contextMenu.hide()

// Events
editor.on(event, handler)
editor.off(event, handler)
editor.once(event, handler)
editor.emit(event, payload)             // emit a custom event (also used by plugins)

// Shortcuts
editor.shortcuts.register(keys, command, label)
editor.shortcuts.unregister(keys)
editor.shortcuts.getAll()           // → Map<keys, descriptor>

// Introspection
editor.getContainer()               // → HTMLElement (the element you passed in; contains .oe-wrapper)
editor.getEditorElement()           // → HTMLElement (the contenteditable node)
editor.getVersion()                 // → string (the package version)
editor.isDestroyed()                // → boolean (guard for async callbacks)
editor.selection.selectAll()        // programmatic select-all via selection API

Events — the frozen public event surface, grouped by category. Every event below is actually emitted; the payload column is part of the frozen contract.

Content & change

Event	Payload	Notes
`beforeChange`	`{ inputType, data, preventDefault() }`	Fires at `beforeinput`, before the DOM mutates. `preventDefault()` cancels the change. Does not fire during IME composition (CJK/accents) — composed text can't be vetoed per-keystroke; use `onChange` to observe the committed result.
`onChange`	`{ html, text }`	Debounced content-change signal. Also driven by `config.onChange` (fn or `{handler,debounce}`).
`beforeSetHTML`	`{ html, preventDefault() }`	Fires before `setHTML()` applies. `preventDefault()` aborts it entirely.
`setHTML`	`{ html }`	Post-hoc: `setHTML()` finished applying.
`reset`	`{ html }`	`reset()` recovered to the last clean snapshot.
`maxLengthExceeded`	`{ current, max }`	An edit was blocked by `maxLength`.

Focus, selection, state

Event	Payload
`focus` / `blur`	native `FocusEvent`
`selectionChange`	selection info object
`stateChange`	`{ key, value }`
`readOnlyChange`	`{ readOnly }`
`directionChange`	`{ direction }`
`themeChange`	`{ theme }`

Commands & history

Event	Payload	Notes
`beforeCommand`	`{ command, args, preventDefault() }`	`preventDefault()` cancels the command.
`afterCommand`	`{ command, args }`
`undo` / `redo`	`{ index }`

Paste — beforePaste / afterPaste (native ClipboardEvent; cancel via the DOM event's preventDefault()).

Lifecycle — beforeInit, init, afterInit, ready, beforeDestroy, destroy (payload: the editor instance).

Autosave — autosaveSaved {key}, autosaveRestored {key,html}, autosaveFailed {key,error}, autosaveDraftSkipped {key,html}.

Plugins (frozen) — pluginInstalled {name,plugin}, pluginUninstalled {name}.

Errors (frozen) — error { error, context } (emitted from plugin/command catch sites; the documented reporting hook — see 16.5.5), clipboardError {operation}.

Feature events — stable from 1.x, NOT frozen: imageSelected/imageDeselected {figure}, tableCellsSelected {cells}, fullscreenEnter/fullscreenExit (editor), sourceEnter {html}/sourceExit, resizeEditor {height}. These are real, emitted, and safe to use, but — like plugins.*/ui.* — they may gain additive changes within 1.x and are not covered by the freeze contract test.

Raw DOM pass-through — NOT frozen: keydown, keyup, input, beforeinput, mousedown, mouseup, contextmenu, paste, compositionstart/update/end, and mutation are re-emitted with their native event object for advanced integrations. Their shape follows the platform, not this API.

Clean output: Every method above works exactly as documented. No undocumented behavior. ✅ Phase 16 complete (1.0.0-rc.1) — the frozen surface (instance methods, namespaced methods, semantic events, config keys, return types, post-destroy safety) is enforced by tests/api-contract.test.js, which fails the build on any drift. Config typos warn (never throw); full config reference in docs/CONFIG.md. beforeChange / beforeSetHTML / beforeCommand are genuinely cancelable via preventDefault(); config.onChange accepts a callback.

Freeze boundary: editor.content/state/selection/commands/history/events/config are frozen at 1.0 — no changes without a major bump. Per the original boundary note, editor.plugins.* and editor.ui.* are "stable from 1.x" (present and working, but may gain additive changes in 1.x) because their contracts leak internal shapes (two-step plugin register, raw-HTML UI sinks) that should settle before being frozen.

PHASE 16.5 — Production Hardening

Goal: Make the editor survive real-world production use — large documents, crashes, and unattended tab closes — before it is published. These are cross-cutting concerns that have been referenced throughout but never owned by a phase; lock them before 1.0.

Milestones:

16.5.1 — Large-document performance: the MutationObserver count recompute (getText() walks the whole doc) is now debounced 150ms + requestIdleCallback-deferred instead of running synchronously per mutation (editor-dom.js). _state.wordCount/charCount are eventually-consistent; getWordCount()/getCharCount() stay exact on demand. StatusBar already computed its own counts on an rAF throttle, so nothing user-visible regresses.
16.5.2 — Performance CI gates enforced: performance.test.js asserts mount ≤100ms, getHTML() on a 10k-word doc ≤50ms, selection update ≤16ms on chromium — it runs in the CI playwright test job, so a regression fails the build. Current headroom is large (~3ms / ~1ms / ~0.4ms).
16.5.3 — beforeunload dirty guard: config.warnOnUnload (default false) — when set and isDirty, triggers the browser's native "leave site?" prompt. Listener bound to window via _boundHandlers so destroy() removes it.
16.5.4 — Crash recovery: autosave drafts now carry a companion <key>:ts timestamp, surfaced as savedAt on autosaveSaved/autosaveRestored/autosaveDraftSkipped so the host can decide if a draft is newer than loaded content (legacy drafts → savedAt: null, backward compatible). editor.reset() re-renders from the last clean snapshot (_state.html), emits reset, and on a render failure emits error {context:'reset'} + falls back to the empty floor.
16.5.5 — Telemetry / error-reporting hook: docs/ERROR-REPORTING.md documents the error event contract ({error, context}, 14 command/plugin catch sites) + Sentry/Datadog/endpoint reporter examples. Honest scope note: a few low-level lifecycle catches log via the logger rather than emitting error. No core change.
16.5.6 — Memory-leak verification: memory-leak.test.js runs 100 create/destroy cycles in all 3 browsers — asserts 0 orphaned .oe-wrapper/.oe-editor, node count returns to baseline, and 0 stylesheet growth (injected styles are inject-once module singletons, deduped across instances — bounded by design, not a per-instance leak).

Clean output: A 10,000-word document edits without jank and passes all perf gates. Closing a dirty tab warns the user. A crash recovers from the last clean snapshot. 100 mount/destroy cycles leak nothing. ✅ Phase 16.5 complete — perf recompute throttled + CI-gated (mount/getHTML/selection budgets, chromium), warnOnUnload dirty guard, timestamped autosave + editor.reset() crash recovery, error-reporting docs, and a 3-browser 100-cycle leak test (0 orphans, 0 style growth).

PHASE 16.6 — Modern Editing UX

Goal: Close the "feels modern" gap against Jodit/CKEditor with the cheap, high-leverage UX features that are buildable in raw JS on infrastructure the editor already has — a slash-command palette, markdown autoformat, @mentions, and Notion-style block drag handles.

Competitive analysis (2026-07) — the full gap list, and where each tier landed:

Tier 1 (CKEditor's real moat — the reasons people actually pay): real-time collaboration + multi-cursor presence, comments/track-changes, AI writing (chat, rewrite, review, translate), version history, and Word-import fidelity. All correctly premium-gated → Phase 19: 19.7 (AI), 19.8 (Collaboration), 19.8b (Restricted Editing), 19.9 (Comments), 19.10 (Version History), 19.6b (Word Import).
Tier 2 (modern editing UX, not yet table-stakes at either competitor — the actual opportunity to differentiate for free): slash-commands, markdown autoformat, @mentions, block drag-reorder. → this phase, 16.6.1–16.6.4.
Tier 3 (polish/compliance gaps): accessibility certification, multi-language UI packs, export/import formats. → Phase 17: 17.10 (WCAG claim), 17.11 (locale packs); export/Word-import already covered above under Tier 1's 19.5/19.6/19.6b.

This phase (Tier 2) is everything CKEditor/Jodit either lock behind a paid tier or haven't polished at all, and this editor can ship it for free because the underlying primitives (command registry, autocomplete grid, cancelable beforeChange) already exist.

Reused infrastructure (no new subsystem invented per milestone):

CommandManager (command-manager.js) — editor.commands.execute() is how every milestone below applies its result, so undo/redo and history snapshots stay correct.
Correction during execution: the emoji/special-chars char-grid.js popup renders inside a centered modal (grid-of-buttons) — the wrong shape for a caret-anchored palette. Rather than force an ill-fitting reuse, a new shared primitive was built: caret-popup.js (createCaretPopup — range-anchored, viewport-clamped, arrow-key nav with wraparound, 11 tests), used by both the slash palette (16.6.1) and mentions (16.6.3).
The input event on the editor root (editor-events.js) — the interception point both slash-detection and markdown autoformat hook into.
escapeLinkBoundary (char-insert-utils.js) — reused verbatim by mentions (16.6.3) before inserting a mention node, exactly as emoji/special-chars already do.
debounce (debounce.js) — reused for the mentions plugin's async source querying.

Milestones:

16.6.1 — Slash-command palette: typing / at the start of an empty block opens a searchable popup listing a curated set of core commands (paragraph, h1–h3, bulleted/numbered list, blockquote, code block, HR — slash-command-data.js; table/image/media are excluded because those toolbar buttons use direct onClick, not the command registry, so they have no registry entry to surface safely); arrow-key nav + Enter to run, Escape to dismiss, typing after / filters by label. Trigger detection is a pure function (slash-detect.js, 8 tests); plugin wiring in slash-command-plugin.js (8 tests).
16.6.2 — Markdown autoformat (typing shortcuts): common Markdown-ish patterns auto-convert as you type — **text**/__text__ → bold, *text*/_text_ → italic, `code` → inline code, # /## /### at block start → heading 1/2/3, - /* → bulleted list, 1. → numbered list, > → blockquote, ``` on its own line → code block. Pure pattern matching in autoformat-patterns.js (20 tests), applied via editor.commands.execute() in autoformat-plugin.js (12 tests) so undo/redo stay correct. Config-gated (autoformat: true by default, added to DEFAULTS/FROZEN_CONFIG_KEYS in lockstep). A genuine live-typing-only bug was found and fixed here — see 16.6.5 below.
16.6.3 — @mentions autocomplete: typing @ (only after whitespace/start, rejecting email-like user@host patterns — mention-detect.js, 7 tests) opens the same caret-popup, sourced from a configurable async config.mentions.source(query) provider; picking an item inserts a non-editable mention node (@label — mention-dom.js) and applies escapeLinkBoundary. Debounced (150ms) with a query-id counter so a late-resolving stale response can never clobber a newer query's results (mentions-plugin.js, 8 tests including the race-condition case). (Moved here from the Phase 19 premium list — cheap to build on existing infrastructure, and a stronger free-tier differentiator than a paid one.)
16.6.4 — Block drag-reorder handles: hovering a top-level editable block (paragraph, heading, list item, blockquote — a narrower REORDERABLE_TAGS set than the general BLOCK_TAGS, deliberately excluding td/th/tr/figcaption) reveals a drag-handle; dragging it reorders the block via pure DOM primitives (block-reorder.js, 11 tests), with a live drop-indicator line and exactly one history.takeSnapshot() per completed drag — never for a no-op drop (block-drag-plugin.js, 6 tests).
16.6.5 — Cross-browser + a11y verification for all of the above: modern-ux.test.js — 11 Playwright specs × 3 browsers (33/33 passing on Chromium/Firefox/WebKit) covering slash-palette open/filter/click + keyboard-only ArrowDown+Enter + Escape; autoformat live bold/heading/list conversion; mentions click + keyboard-only + email-pattern rejection; block-drag real pointer-driven reorder + single-undo-reverts-whole-drag. Caught a real bug jsdom unit tests could not: typing **bold** character-by-character fired italic prematurely at the 7th keystroke (**bold*), stranding the outer ** — invisible to any single-shot jsdom input event, only reproducible by simulating actual incremental keystrokes. Fixed in matchInlinePattern (reject a single-char marker match when the character immediately before it is the same marker — i.e. it's really the second half of an in-progress double-char pair) and locked in with 2 permanent regression tests that iterate every incremental prefix of **bold**/__bold__.

Clean output: Typing / inserts a heading/list/quote without touching the toolbar. Typing **bold** converts live, correctly, even mid-keystroke. Typing @ and picking a user inserts a real non-editable mention. Dragging a block's handle reorders it with one undo step. All four are keyboard-accessible and verified across Chromium/Firefox/WebKit — 1894 unit tests + 536 e2e tests green project-wide, zero regressions.

PHASE 16.7 — Competitive Parity Pass

Goal: Close the concrete, verified gaps found by a full Phase 0–16.6 re-audit plus a feature-by-feature comparison against CKEditor 5 and Jodit — every milestone below traces to a specific competitor behavior this editor doesn't yet match, confirmed by reading this codebase's actual source, not assumed from a feature-name list.

Audit method (2026-07): independent agents (a) re-ran every gate (lint/unit/build/ contract-test) fresh rather than trusting prior claims, (b) read the table/image/link/ list/paste/find-replace/source plugin source directly and compared it line-by-line against researched CKEditor 5 and Jodit behavior, (c) researched both competitors' docs in depth (not just marketing copy) for 10+ feature areas. Result: Phases 0–16.6 are genuinely complete — 1894/1894 unit tests passing, 0 lint errors, api-contract.test.js shows zero drift between DEFAULTS and FROZEN_CONFIG_KEYS, zero TODO/FIXME markers in packages/core/src. The only defects found were cosmetic (stale test-count prose, 3 undocumented-but-working config keys) — fixed in 16.7.0 below. Everything else in this phase is genuinely new work, not a correction.

Where this editor is already ahead, confirmed (not assumed): Word/Google-Docs paste cleanup (word-lists.js reconstructs nested lists from Word's fake-bullet paragraphs via an explicit level-stack algorithm — deeper than anything found in Jodit's docs), the image plugin's breadth (dual resize paths — drag and a numeric dialog with aspect-lock — plus a real XHR upload adapter with progress/abort, srcset preservation, and a link-wraps-image path that survives resize/align), and autosave (real timestamped-draft crash recovery for free — Jodit's equivalent, the Backup plugin, is PRO-only/paywalled).

STATUS: Phase 16.7 COMPLETE (2026-07-13). All 10 milestones (16.7.0–16.7.9) done and live-verified across Chromium/Firefox/WebKit. Two real bugs were caught only by real-browser e2e (not jsdom): the typed-autolink nbsp/caret handling (16.7.2) and a stale status-bar count after programmatic setHTML (16.7.9) — both fixed. Final gate: 1964 unit + 638 e2e passing (13 skipped, 0 failed), 0 lint errors, all files ≤300 lines.

Milestones:

Explicitly deferred, not forgotten:

Region-level restricted editing (lock part of a document while leaving the rest editable) — real gap versus both competitors' composable readonly-lock models, but substantial enough to stay under Phase 19: 19.8b as already planned, not folded in here.
Image crop/rotate — Jodit has a full modal image editor; CKEditor doesn't either (paid CKBox only). Confirmed NOT a universal gap — now scheduled as Phase 20.5.
Excel/Sheets-specific paste-table cleanup — confirmed absent in both this codebase and (per research) undocumented in Jodit's own docs. An opportunity, not a competitive deficiency; now scheduled as Phase 20.4.
WCAG 2.1 AA certification claim + axe-core sweep — CKEditor is WCAG 2.2-certified with a published VPAT and a documented Alt+F10/Alt+F9/Alt+0 focus model; this is arguably the single largest remaining gap, but it's already scoped as Phase 17.10 and belongs there (it's a publishing-readiness gate, not a feature gap).

Clean output: Nested lists auto-vary their marker per depth. Typing a bare URL then space/Enter turns it into a link without needing to paste it. [ ] creates a real checkbox list item. Find & Replace has a whole-word toggle. Table formatting is split into table-wide and per-cell scopes with real border-width/style choices. Clicking a column/row header selects the whole column/row. Source view shows syntax-highlighted HTML. Selecting text shows a selection-specific word/char count alongside the document-wide one.

PHASE 17 — npm Publishing

Goal: Ships as @open-editor-hq/core — a proper npm library, usable via script tag or bundler. One name forever: the rc publishes under the next dist-tag on the final name; 1.0.0 promotes the same name to latest. (The earlier two-name plan — a omi-open-editor rehearsal → scoped rename at stable — was retired on 2026-07-14 once the open-editor-hq orgs were actually claimed: dist-tags already provide the rehearsal safety, and a single identity is simpler for users. Worst-case rc mistake burns a version number, never the name.)

Distribution posture (decided 2026-07-14): minified-only. The tarball ships production builds exclusively — per-module-minified ESM tree (tree-shaking preserved), minified CJS/UMD/single-file-ESM, no sourcemaps, no public repository for now. MIT license kept. Rationale: the owner isn't ready to publish readable source; closed→open is always possible later, open→closed never is. Standing recommendation, unchanged: the industry standard (Jodit, CKEditor, TinyMCE) is open core + closed premium, and opening the free core remains this project's strongest adoption wedge — revisit at the 1.0.0 promotion with real rc traction data. CI enforces the posture (*.map files in dist fail the build).

Package identity (verified against the live registry):

Bare open-editor is permanently unavailable — owned by sindresorhus, actively maintained at v6.0.0; npm disputes never transfer active packages. Not obtainable, ever.
Future stable identity: @open-editor-hq/core, with @open-editor-hq/react|vue|angular (Phase 18), @open-editor-hq/locale-* (17.11), and @open-editor-hq-premium/* (Phase 19) as siblings — the scoped family pattern used by CKEditor/Tiptap/Lexical/Angular themselves. Identity history (2026-07-14): the originally-planned open-editor org name turned out to be TAKEN in npm's shared user/org namespace — the create-org API redirected to an existing entity (surfacing as a broken page / "<h1>Redirect…" JSON-parse console error; a throwaway org name created fine in the same session, isolating the cause). Fallback ladder was pre-agreed; rank 1 won: open-editor-hq ("headquarters" — the standard qualifier convention: vuejs/expressjs/nestjs don't own their bare words either; -js was ranked below it due to Editor.js adjacency). CLAIMED (owner-account, 2026-07-14): npm orgs open-editor-hq + open-editor-hq-premium, GitHub org open-editor-hq — one string across both registries. The identity hard-locks only at 17.13 (first stable publish); until then a rename costs nothing (the rc never references the scope).
The rc and the stable share the single name @open-editor-hq/core, separated only by dist-tags (next vs latest) — no rename, no deprecation dance, users only ever learn one install command.
Product name stays "Open Editor" everywhere (GitHub/docs/marketing); the class stays OpenEditor and the CSS prefix stays oe- — package name ≠ frozen API, and renaming the frozen surface would break the 1.0.0-rc contract for zero benefit.
Ownership/migration rule: initial setup under the personal account is fine — org ownership transfers later via invite → promote-to-Owner → remove (zero user impact, no republish). The one hard rule: publish under the ORG scope, never a personal scope — personal scopes are permanently welded to their account.

Milestones (execution order; full gate — lint + unit + e2e — after every step):

Execution order: 17.0 → 17.1 → 17.2 → 17.3 → 17.4 → 17.6 → 17.7 → 17.8 → 17.12 (rc live on next) → 17.9 → 17.10 → 17.11 → 17.13 (1.0.0 → latest). Effort ranking: 17.3 (types) > 17.7 (size) > 17.10 (a11y sweep) > everything else; 17.0–17.2, 17.4 are mostly mechanical, 17.8/17.12 are checklists.

Clean output: npm install @open-editor-hq/core@next works today — VERIFIED LIVE (plain installs also resolve to the rc, since npm gives a first publish the latest tag; 17.13 re-points it at 1.0.0). Script tag UMD works from a CDN — VERIFIED LIVE. Bundle sizes measured and CI-gated; no sourcemaps or readable source in the tarball (posture enforced by CI). A third party can write a plugin following the guide against the published package. A published accessibility statement backed by an axe-core report. At least a few non-English UI locales ship complete. The open-editor-hq and open-editor-hq-premium orgs are owned (npm + GitHub), and ownership is transferable to the production account with a role change.

PHASE 17.5 — Free-Tier Competitive Sweep

Goal: Close every remaining free-tier gap versus CKEditor 5 (GPL package, v48.3) and Jodit 4.x (MIT core) — plus ship free a handful of features BOTH competitors charge for — so the launch-day comparison table has no losing rows.

Source (2026-07 competitive analysis, post-16.7): three independent research passes — CKEditor 5 verified against the actual ckeditor5 vs ckeditor5-premium-features npm package split at v48.3.0 (the marketing site mislabels several free features as premium), Jodit verified against its src/plugins source + PRO page at 4.12/PRO 4.13, and a market-demand pass over HN/GitHub-issues/2025-26 editor surveys. Every milestone below was then checked against this codebase before being listed (e.g. table column drag-resize looked like a gap but is already built — 11.8 table-resize.js — so it is NOT here). Discipline is identical to 16.7: one milestone at a time, live-verify in all 3 browsers, full gate after each, honest bug accounting in the checkbox note.

Ordered smallest-first for momentum. Config-freeze contract applies: any new config key updates BOTH editor-config.js DEFAULTS and api-contract.test.js FROZEN_CONFIG_KEYS in lockstep; any new *-styles.js registers in no-color-literals.test.js.

Milestones:

Clean output: Every feature CKEditor's GPL package ships is either present or consciously N/A — and change case, format painter, line height, slash commands, source highlighting, to-do lists, emoji, mentions, and autosave-recovery (each premium/PRO at one or both competitors) are all free here, keyless, zero-dep. The comparison table at launch has no losing free-tier rows.

PHASE 18 — Framework Wrappers

Goal: Native components for React, Vue, Angular that feel idiomatic — the #1 adoption unlock (most integrators won't touch a bare-DOM editor).

Deep analysis (2026-07-14) — the four traps every editor wrapper falls into, and this design's answers:

The controlled-component trap (the classic wrapper bug): naively piping value → setHTML on every render destroys the caret and can loop with onChange. Design: the editor is uncontrolled by default; the value prop is initial content + EXTERNAL-change sync only — the wrapper diffs (value !== editor.getHTML()) and skips syncs for changes that originated inside the editor. Both modes (18.2) get dedicated caret-stability e2e tests — typing must never jump.
React 18 StrictMode double-mount: effects run create→destroy→create in dev. The editor's create/destroy is already proven idempotent by the 100-cycle leak test (16.5.6) — the wrapper leans on that and gets its own StrictMode test.
SSR (Next.js): the core's module graph is import-pure (sideEffects: false, proven by 17.6) so IMPORTING is SSR-safe; only construction needs a DOM. The React wrapper ships "use client"-ready with documented dynamic-import patterns — a real differentiator vs wrappers that crash at import (matters doubly: Phase 21's site IS Next.js and will dogfood it).
Reactive-prop honesty: only some editor state is runtime-mutable. Reactive props: value, readOnly (→setReadOnly), theme (→setTheme), direction (→setDirection). Everything else (locale, plugins, most config) is construct-time — changing those triggers a documented, clean recreate (via key in React) rather than silent misbehavior. The docs state exactly which prop does which — no pretending everything is reactive.

Shared design: events → props (onChange, onReady, onFocus, onBlur, onError from the frozen event map); the editor instance exposed (forwardRef / template ref / @ViewChild); plugins prop takes factory instances installed on mount; TypeScript types REUSED from the core's index.d.ts (OpenEditorConfig is the prop type — zero type forks). Each wrapper: its own package under the owned org scope, peerDependencies on its framework + the core, same minified-only build posture, own size gate (wrappers must stay tiny — a few KB), own d.ts, RTL/jsdom unit tests + a real consumer app driven by Playwright.

Milestones (execution order — React first, it unblocks Phase 21's dogfooding):

18.1 — (done 2026-07-14) React wrapper (@open-editor-hq/react, new packages/react): JSX-free source (zero build transforms), 1.9KB minified shim, react + core as peer deps, minified-only distribution posture, hand-authored d.ts that REUSES the core's types (zero forks). value/onChange/onReady/onFocus/onBlur/ onError, forwardRef handle (.editor, getHTML, getMarkdown, focus), plugins factory prop, reactive readOnly/theme/direction, everything else documented construct-time. 7 unit tests (RTL/jsdom) — including the no-echo-loop proof: setHTML is spied and NEVER re-entered by the editor's own onChange round-trip.
18.2 — (done 2026-07-14) Controlled + uncontrolled with caret-stability proof, LIVE: a real Vite+React 19 app in StrictMode, built from packed tarballs, driven in Chromium — character-by-character typing in fully controlled mode (value + onChange→setState) produced byte-exact text with the caret never jumping; StrictMode double-mount left exactly ONE live editor; external value changes sync in; reactive theme applies; the ref surface works from app code; zero page errors.
18.3 — (done 2026-07-14) Vue 3 wrapper (@open-editor-hq/vue, packages/vue): render-function source (no SFC compiler, zero transforms), v-model with the same no-echo-loop diffing as React (spied setHTML never re-entered by the editor's own update), emits change/ready/focus/blur/error, reactive readOnly/theme/direction, plugins prop, template-ref surface (editor/getHTML/getMarkdown/focus). Vue lesson captured in code comments: accessor getters on expose() objects are not reliably proxied — the instance is exposed as a shallowRef (auto-unwrapped), and tests grab it via the public ready emit.
18.4 — (done 2026-07-14) useOpenEditor composable (bring-your-own element ref, lifecycle-bound) + the live proof: a real Vite+Vue 3.5 app from packed tarballs driven in Chromium — char-by-char v-model typing with a byte-stable caret, external sync, reactive theme, ref markdown, zero page errors. 5 unit tests (@vue/test-utils).
18.5 — (done 2026-07-14) Angular wrapper (@open-editor-hq/angular, packages/angular): standalone component + ControlValueAccessor — works with [(ngModel)] AND reactive forms; setDisabledState → editor read-only; outputs ready/changed/focused/blurred/errored; reactive theme/direction; pending-value buffering for CVA writes that arrive before view init. Built the platform-correct way: ng-packagr partial-Ivy FESM (the one wrapper where a no-build shim isn't acceptable to the ecosystem), then terser'd + sourcemaps stripped to keep the minified-only posture (2.9KB FESM). Live proof in a REAL ng new Angular 19 app: AOT build consumes the packed dist tarball cleanly; Chromium drive — char-by-char ngModel typing with a byte-stable caret, external sync, reactive theme, CVA disabled→readOnly. Zero page errors.
18.6 — (done 2026-07-14) Dependency audit: React and Vue wrappers carry ZERO dependencies (framework + core as peers only). Angular carries exactly one — tslib, the Angular platform's own mandated import-helper library, present in every Angular app by definition (the documented exception).

Audit note (2026-07-16): the "live-proven from packed tarballs" claims below were real one-time manual drives; those throwaway consumer apps are NOT in the repo and were NOT reproducible in CI. Automated coverage has since been added and wired into CI: React (7), Vue (5), and — closing a zero-coverage hole — Angular (9, ControlValueAccessor logic). The live browser drive remains the historical proof; the unit suites are the standing regression guard.

18.7 — (done 2026-07-14) Each wrapper is its own npm package under the owned org scope with its own npm-facing README (quickstart, reactive-prop contract, ref surface); publishing happens at the month-end release (Angular publishes its dist/ per ng-packagr convention). Live demo routes on the Phase 21 site: reserved. PHASE 18: 7/7 COMPLETE.

Clean output: React/Vue/Angular demo apps all work with the value/v-model/CVA pattern; typing never drops the caret in controlled mode; StrictMode clean; a Next.js page imports the React wrapper without SSR crashes.

PHASE 19 — Premium Layer

Goal: License-gated features that generate revenue, completely separated from free core.

Milestones:

Document-app pack (added 2026-07 competitive analysis — all verified paid-only at CKEditor, none previously in this plan):

19.12 — Premium plugin: Footnotes — removed 2026-07-17. Built, then torn down after real-world testing: a footnote note's <li> could not be made to reliably coexist with native contenteditable list-editing (Enter/Backspace kept forking or merging the note in ways that broke the one-<li>-per-marker invariant, even after two dedicated fix passes). Combined with no confirmed demand for it (users wanted a plain numbered list, which core already provides), it wasn't worth the ongoing fragility. @openeditor-premium/footnotes and its e2e were deleted; the footnotes feature id stays registered but deprecated: true per the entitlements additive-only rule (never remove/rename a shipped id); the footnote-only sanitizer allowlist entries (sup id/contenteditable/data-oe-footnote-ref, ol/li data-oe-footnotes/data-oe-footnote) were reverted since nothing uses them now.
19.13 — Premium plugin: Multi-level legal lists — 1 / 1.1 / 1.1.1 numbered lists with Word round-trip fidelity (pairs with 19.5/19.6b converters). CKEditor premium.
19.14 — Premium plugin: Document outline + Table of contents — sidebar heading tree (click-to-navigate) + insertable auto-updating ToC block. CKEditor premium. The heading data already exists in the canonical DOM — this is UI + anchor plumbing (reuses 17.5.7 bookmarks).
19.15 — Premium plugin: Merge fields + Content templates — {{placeholder}} tokens with preview/data modes (document automation / mail-merge), plus predefined insertable content structures. CKEditor premium; Jodit gates Templates behind OEM.
19.16 — Premium plugin: Pagination — live page boundaries matching PDF/Word print output (depends on 19.5 export engine for fidelity). CKEditor gates this behind its highest tier.
19.17 — (evaluate only) Math — MathML formula editing. Even CKEditor outsources this (third-party MathType). Evaluate demand post-launch before committing; do not build speculatively.

Explicitly skipped (2026-07 analysis — low demand / gimmick, do not build): Google-search button, virtual keyboard, button generator, content minimap, Mermaid diagrams.

Clean output: License key unlocks features. No premium code ships in the free build. Collaboration works with two browser tabs open simultaneously.

PHASE 20 — Engineering Moats (ongoing, post-launch)

Goal: Win on the axes nobody solves well at any price — per the 2026-07 demand research, these are reputation moats, not feature-list rows: large-document performance, mobile IME correctness, and offline resilience. Runs in parallel with 18/19 after Phase 17 ships; no milestone here blocks a release.

Milestones:

20.1 — Large-document performance benchmark suite: a public, reproducible benchmark (Playwright-driven) — load/typing-latency/paste time at 10k/50k/100k-node documents, numbers published in the README. Context: Lexical degrades/crashes around ~8,200 nodes in public stress tests; ~80% of surveyed developers rank performance first. Extends the existing 16.5.2 perf-budget harness from budget-gates to published comparative numbers. Fix what the benchmark exposes; the number IS the feature.
20.2 — Android IME / composition hardening: real-device test matrix (Gboard, Samsung Keyboard, SwiftKey; CJK + autocomplete composition) for the known contenteditable composition traps — "contenteditable on Android is the absolute worst" remains an open industry wound. The _isComposing guards exist (Phase 14); this milestone is systematic real-device verification + fixes, and a documented known-behaviors page for what platform bugs can't be fixed.
20.3 — Offline-first autosave: IndexedDB draft provider (larger quota than localStorage, structured snapshots), save-on-visibility-change, and a sync-when-online hook — the local-first storage layer that 19.8's collaboration can later share. No mainstream embeddable editor ships offline-first persistence as a first-class feature.
20.4 — Excel/Sheets paste-table cleanup: dedicated cleanup pass for spreadsheet clipboard HTML (colgroup widths, number-format spans, merged-cell artifacts) — absorbed from 16.7's deferred list; confirmed absent in Jodit's docs too, so this is an ahead move, not parity.
20.5 — Image crop / rotate editor: in-editor crop + rotate on the existing properties/action-bar surface (canvas-based, zero-dep) — absorbed from the long-standing "deliberately separate" future line. Jodit ships crop/resize free; CKEditor only via paid CKBox. Decide free vs premium at build time (lean free: it's a parity feature).
20.6 — File manager: server-connector-based media/file browser (folders, thumbnails, rename/delete, pick-to-insert). Jodit ships one free (connector required); CKEditor sells CKBox. Candidate for premium "Finder-style" treatment or a minimal free reference implementation + documented connector protocol — decide when 19 revenue shape is known.

Clean output: Published benchmark numbers a competitor has to answer. A real-device Android typing matrix in CI or a documented manual protocol. Drafts survive a crashed tab offline and sync when back online. Spreadsheet paste produces clean tables. Images crop in place. Files browse from the server.

PHASE 21 — Web Platform, Part 1: Public Site + Playground (NEW repo: `open-editor-web`)

Goal: The public face — landing page, Jodit-style live playground, docs — built as the PUBLIC HALF of one fresh full-stack web project that will also carry the admin platform (Phase 23) and commerce (Phase 24). Decision (2026-07-14, owner): one fresh project, not scattered apps — recommended stack Next.js (SSG for the public pages, server runtime + RBAC for /admin later; a NestJS API tier is optional if API separation is preferred at build time). Repo private; the DEPLOYED site is public (deployment visibility ≠ repo visibility — also fits the closed-source stance).

Milestones (built 2026-07-14/15 in the separate open-editor-web repo — Next.js 16.2.10, App Router, TS, Tailwind v4, fully static output; committed 58f1eb9):

21.1 — Project scaffold: separate repo, CI workflow (lint + build + axe gate), live core from the registry + vendored react wrapper tarball (file:vendor/… — wrappers are unpublished until month-end; swap to registry at 25.2). Deviations from spec, deliberate: Postgres/ORM NOT scaffolded (dormant code helps nobody — arrives with Phase 23); deploy pipeline pending the hosting decision (CI file ready).
21.2 — Landing page: live hero editor (dynamic({ssr:false}) — the site dogfoods the real packages), measured claims (0 deps / 61KB gz / 2800+ tests / 0 license keys), feature grid, install snippet.
21.3 — Playground: all 19 plugins toggleable; theme/locale (en/es/fr/de/ar)/ direction switchers (Arabic auto-sets RTL); the config reflector emits the exact imports + new OpenEditor(…) + plugin installs for the current toggles, with Copy. Verified live: SITE LIVE DRIVE 10/10 checks (typing, toggle→toolbar+reflector, Arabic UI+RTL+locale reflection), zero page errors.
21.4 — Docs: 8 markdown files (CONFIG/THEMING/THEME-TOKENS/PLUGINS/ ACCESSIBILITY/SECURITY/ERROR-REPORTING/CHANGELOG) synced from this repo via scripts/sync-docs.mjs (committed copies, editor repo = source of truth), rendered SSG with GFM tables.
21.5 — Comparison page vs CKEditor/Jodit — honest rows (license keys, size, features), each linking to live playground proof. Framework demos deferred to the docs-site pass at 25.2 (wrappers publish then; READMEs already written 2026-07-15).
21.6 — Quality gate in CI: axe WCAG 2.0 A/AA on all 5 routes — PASS exit 0 (fails build on any critical/serious violation; live editors mounted during scan). Deviation: Lighthouse deferred until the site has a real deploy target — scoring localhost is noise; tracked for the deploy moment.

Clean output: A public URL where a stranger tries everything in 30 seconds, copies a working config, and installs.

PHASE 22 — Entitlements Foundation (client-side, in this repo)

Goal: The license plumbing the premium tier stands on — built BEFORE the first premium plugin so 19.x plugins are entitlement-gated from day one, and BEFORE the platform (23) so it has a stable contract to issue against.

Design decision pending owner approval: PHASE-22-DESIGN.md (2026-07-15) — recommends ES256 via native WebCrypto instead of Ed25519 (Ed25519 isn't available at the project's browser floor; ES256 ships zero crypto code), with alg+kid agility so Ed25519 slots in later. Includes the concrete token contract, domain semantics, and the adversarial-sweep matrix.

Design decisions (the contract):

Feature registry: stable, versioned feature IDs (export.pdf, collab.rt, trackChanges, …) — the shared vocabulary between premium plugins, licenses, and the admin panel's plan builder. Plans compose feature IDs; new plans never require code changes anywhere.
License format: signed JWT (ES256 (ECDSA P-256) via native WebCrypto, alg+kid header for algorithm-agility and key rotation — amended 2026-07-15 from Ed25519 per PHASE-22-DESIGN.md; Ed25519 is the designated successor once the browser floor supports it), verified OFFLINE with an embedded public key (19.1) — no phone-home to function. Payload: { features[], limits{}, domains[], seats, plan, customer, exp, iat }. The license snapshots its feature set at issuance (renewals re-issue) so offline verification never needs the plan database.
FeatureManager (19.2): premium plugins declare required feature IDs; install is gated; expiry/absence degrades gracefully with a non-blocking notice (19.3).
Dev issuer: a local script that signs development licenses — Phase 19 plugins get built and tested against real license mechanics long before the platform exists.

Build status (2026-07-15): 22.1–22.4 are BUILT in a fully isolated package, packages/entitlements (@openeditors/entitlements, private) — it imports nothing from the editor core and the core imports nothing from it (verified: zero cross-imports, core source digest unchanged, all 2,056 core tests still green). 32 entitlements tests pass, including the full 22.4 adversarial sweep. Algorithm is ES256 via native WebCrypto (not Ed25519) per PHASE-22-DESIGN.md. Remaining: 22.5 (anti-sharing layers — lands with the Phase 23 platform that issues/revokes).

Milestones:

22.1 — (built 2026-07-15) Feature-ID registry + conventions (feature-registry.js): dot-namespaced, additive-only, never-renamed IDs with shape validation and a grant-list validator the issuer enforces.
22.2 — (built 2026-07-15) License verification — ES256 (ECDSA P-256) JWT via native WebCrypto, offline, keyring with alg+kid for rotation + algorithm-agility (Ed25519 successor path), expiry/iat-skew/domain semantics, every path fails closed. Dev-domain exception (the Jodit rule): localhost, 127.0.0.1, *.local, *.test and the localhost family always run WITHOUT any key (premium included, quiet "development mode" note) — development never fights the license; only production domains need the key.
22.3 — (built 2026-07-15) FeatureManager + premium-plugin gating contract (gate() returns allow/decline + reason; absent/expired/invalid license degrades to free tier, never throws). Premium delivery model (decided 2026-07-15): premium code ships as a NORMAL PUBLIC npm package (minified, dormant without a valid key) — one ordinary npm install, no private registry, no tokens, no extra steps; the customer experience is exactly "paste licenseKey in config → features activate offline." Kept as a separate package (not folded into the engine) so heavy premium features never bloat free users' bundles or the size budgets; the CLI later makes even that install invisible (npx openeditors add premium).
22.4 — (built 2026-07-15) Dev license issuer (./issuer, Node-only, node:crypto P-256, DER→P1363 for JWS/WebCrypto compatibility) + the adversarial sweep — forged signature, tampered payload, expired, not-yet-valid, wrong domain, apex-vs-wildcard, unknown kid, alg-confusion (none/HS256), malformed tokens, broken payload shape: all verified to fail closed. Real issuer-signed tokens round-trip through the WebCrypto verifier.
22.5 — Anti-sharing enforcement (one payment = one customer) — built: domain-bound keys (born bound at purchase) + a persisted refresh-event fetch-log feeding a soft-flag detector (distinct origins/IPs over a window) → human-confirmed admin review/revoke (never auto-revokes, to avoid false-positives on CDN/multi-PoP customers). Layered, engineering-honest design — any client-side key can be COPIED, so enforcement = hard binding + detection + response, the same model every serious editor vendor uses: (a) Domain lock (the hard wall): every license is bound to the customer's domain(s); the editor verifies location.hostname against the key offline — a key issued for customer.com is inert anywhere else. This alone kills casual sharing for web products. The domain is collected AT PURCHASE (decided 2026-07-15): checkout requires the production domain(s) up front, so every key is born already bound — an unbound key never exists. (Dev domains are exempt per 22.2, so the customer can build before their production domain even goes live.) (b) Seats/limits in the payload for per-editor/per-user pricing tiers. (c) Activation pings (detection): premium builds send an optional, privacy-light activation beacon (license id + hostname hash); the platform flags one license appearing across many unrelated hosts → admin sees it on the abuse dashboard (23.4) and revokes (23.2). Offline/air-gapped customers are exempted by contract tier. (d) Response: revocation list + non-renewal; degraded-with-notice, never remote-brick. What this deliberately does NOT promise: DRM-grade impossibility — that doesn't exist in JavaScript, and pretending otherwise is how vendors ship user-hostile phone-home requirements. Binding + detection + revocation is the honest, industry-proven ceiling.

Clean output: A premium plugin can exist: it installs with a valid dev license, refuses politely without one, and no amount of client-side tampering unlocks it.

PHASE 23 — Web Platform, Part 2: Admin Panel + License Service (same `open-editor-web` repo)

Goal: The fully-admin-controlled back office, behind auth in the same fresh web project. The core design — packages via TWO PIPES (decided 2026-07-14): a Package is ONE feature matrix the admin edits (bold ✓, lists ✓, color ✗, tables ✓, PDF export ✓, collaboration ✗ …) that emits BOTH artifacts at once:

a config profile (JSON) for core/visible features — which toolbar buttons and plugins that package's editor ships; delivered via a profile endpoint the customer integration loads. No DRM needed for core features; fully dynamic; editable live.
a signed license (Phase 22 JWT) for premium features — paid code, offline- verified. Optionally carries core-feature flags too for hard-enforced B2B deals (license present → honored even for core; license absent → full free editor, so plain npm users are never affected). New plans, price changes, feature re-bundling: admin dashboard only — engineering is never in the loop.

Milestones:

23.1 — Data model — built (NestJS + TypeORM + MySQL): Features (vendored catalog, drift-tested vs the editor) → Packages (admin-composed feature matrix + price/interval/isFree metadata) → Customers → Licenses (issued snapshots: domains, expiry, status, term boundary) → AdminUsers + dynamic Roles/Permissions. (Seats + a dedicated append-only AuditLog are NOT built.)
23.2 — License service — built, but as ES256 (ECDSA P-256) JWS, not Ed25519 (byte-compatible with the editor's WebCrypto verifier). Renewal (re-issue), revocation (status flip + delivery-time check), key rotation (kid + retired keys). Signing key is server-only, env-injected, never in the web tier.
23.3 — Admin panel — the matrix — built: package builder UI (per-feature checkboxes across core + premium, grouped), license issue/renew/revoke/regenerate/ rebind, customer CRUD, order admin (incl. force-fulfill a stuck order), search. Sidebar shell + Overview dashboard. (A live embedded-editor preview is NOT built.)
23.4 — Admin control — partial: dynamic RBAC roles + permissions (create roles, assign, escalation guards, last-admin lockout), admin-user CRUD, overview dashboard (licenses/orders/revenue/attention). NOT built: admin 2FA, a dedicated append-only audit log, activation pings, admin-editable public-site copy.
23.5 — Hardening: rate limits (done — tiered throttler on auth/checkout/ refresh), plus backup/restore drills, staging environment, penetration checklist on the auth + signing paths (remaining).

Clean output: An admin creates a "Business" package by ticking features, hits publish — a customer's editor (config profile + license) reflects exactly that matrix, offline-capable, revocable, and every admin action is attributable.

PHASE 24 — Web Platform, Part 3: Commerce & Customer Portal (same `open-editor-web` repo)

Goal: Self-serve: customers buy, renew, and manage licenses without an admin in the loop.

Milestones:

24.1 — Customer accounts + portal (view licenses/keys, domains) — built: passwordless magic-link auth, "my licenses" page, key reveal/copy, domain rebind. (Seats + in-portal invoices NOT built — invoices are covered by Stripe's own receipts/hosted invoice history rather than surfaced inside this portal.)
24.2 — Billing integration (Stripe): checkout collects the production domain(s) as a required field → automatic license issuance with the key born domain-bound (22.5a). Renewals → silent-refresh re-issue (bounded by the paid term). Billing is ONE-TIME (mode:'payment'), not subscription — so the "failed payment → grace" path does not apply (there is no recurring charge to fail; a term simply lapses and the customer re-purchases). Never remote-bricks — offline licenses expire on their own terms.
24.3 — Trials: time-boxed full-feature licenses, self-serve — NOT built (optional conversion feature; nothing else depends on it).
24.4 — Email lifecycle — built: license-delivery email, expiry-reminder email (sent inline on near-expiry refresh, once per term), key-rotated email. (No dedicated branded receipt email — Stripe emails its own payment receipt.)

Clean output: A stranger goes from the Phase 21 playground's "try premium" button to a paid, working license with zero human involvement.

PHASE 25 — Distribution: `openeditors` CLI + name migration (decided 2026-07-15)

Goal: One brand, one command. Full proposal: PROPOSAL-CLI.md.

Naming decision record (2026-07-15, supersedes @open-editor-hq/* for all forward-looking work; historical milestone notes keep the old names as facts):

Bare open-editor/openeditor/open-editor-cli are permanently impossible (Sindre Sorhus's packages + npm's punctuation-similarity rule — verified by a real rejected publish). The @openeditor scope belongs to an unrelated active product (found 2026-07-15).
Final family — all claimed live on npm (v0.0.2 placeholders, owner ami-hasan-parselab, managed by the openeditors org): openeditors (CLI), openeditor-text (engine), openeditor-text-react / -vue / -angular (wrappers), openeditor-image (future). The openeditors npm org also secures the @openeditors scope defensively.
Commands: npx openeditors add text (zero-install door) and, after npm i -g openeditors, literally openeditor add text (bin names have no similarity rule). Old orgs (open-editor-hq, open-editor-hq-premium, …) stay parked as brand protection; @open-editor-hq/core retires at the month-end migration (deprecation notice pointing to openeditor-text).

Milestones:

25.1 — (built 2026-07-15) CLI v1: add text — detects package manager (npm/pnpm/yarn/bun from lockfiles) + framework (React/Vue/Angular/none from package.json), installs openeditor-text + the right wrapper, prints framework-exact starter code (kept in lockstep with the wrapper READMEs). --dry-run, --version, help; both bins (openeditors + global openeditor). Small by design (detect → install → print); no config mutation in v1. New packages/cli, zero deps, 14 unit tests + live-driven against fake React/Angular projects. openeditors@1.0.0 LIVE on npm (2026-07-15) — verified end-to-end from the public registry: one command in a scratch React project detected, installed engine + wrapper (0 vulnerabilities), and printed the starter code.
25.2 — (done 2026-07-15) Name migration: monorepo packages renamed to openeditor-text / -react / -vue / -angular (+ private -ui/-toolbar stubs), engine README adapted, all builds green, 2056 core + 7 react + 5 vue
- 14 cli tests pass. Published over the placeholders same day: openeditor-text@1.1.0 + all three wrappers + the CLI; @open-editor-hq/core deprecated with a pointer. Web repo runs on the registry packages (vendored tarballs retired). Site follow-up delivered same day: the playground's config reflector now has framework tabs (JavaScript / React / Vue / Angular) emitting wrapper-exact code — closes the one funnel gap vs CKEditor's Builder. PHASE 25: 25.1 + 25.2 COMPLETE; 25.3 waits on Phases 22/23.
25.3 — CLI Phase-22/23 hooks (later, with those phases): openeditors login, license-key activation, add premium.

Clean output: A stranger with an empty React/Vue/Angular app runs ONE command and has a working, styled editor plus paste-ready code — and every doc leads with that command.

Browser Support

Every phase is built and tested against all five targets. No feature ships until it works in all of them.

Browser	Engine	Min Version	Notes
Chrome	Blink/V8	90+	Primary dev target
Edge	Blink/V8	90+	Identical to Chrome engine, test separately for OS-level quirks
Firefox	Gecko	88+	Different selection behavior, different `execCommand` results
Safari	WebKit	14+	Hardest target — most selection bugs, strictest clipboard rules
Safari iOS	WebKit	14+	Virtual keyboard, touch selection, viewport resize
Android Chrome	Blink/V8	90+	Touch selection handles differ from iOS, different virtual keyboard behavior

Cross-Browser Problem Map

Every known browser-specific problem, which phase it hits, and exactly how it is solved.

Selection & Cursor

Problem	Browser	Phase	Solution
`getSelection()` returns wrong range after programmatic DOM change	Safari	3	Always `removeAllRanges()` + `addRange()` when restoring — never mutate an existing range
Selection lost after toolbar button click	All	7	Save range on `mousedown` (fires before `blur`), restore before executing command
`anchorNode` / `focusNode` swapped when selecting right-to-left	Firefox	3	Normalize by comparing positions, always produce `start < end`
`getRangeAt(0)` throws when selection is empty	Safari	3	Guard with `selection.rangeCount > 0` before every call
Collapsed selection at wrong position after `innerHTML` set	All	2	After `setHTML`, explicitly place cursor at end via `Range.selectNodeContents`
Selection spans across table cells unexpectedly	Chrome	11	Clamp selection to single cell when cursor is inside table
Double-click selects trailing whitespace differently	Safari vs Chrome	3	Normalize selected text with `.trim()` before use

Input & Keyboard

Problem	Browser	Phase	Solution
`beforeinput` event not fired for all input types	Firefox < 87	1	Fall back to `keydown` + `input` pair for those input types
IME composition: `keydown` fires with `key: 'Process'` during composition	Chrome/Edge	1	Check `event.isComposing` flag and skip command handling during composition
IME composition: `compositionend` fires before or after `input` inconsistently	Safari vs Chrome	1	Always handle final content in `compositionend`, ignore `input` during composition
`Enter` key in contenteditable creates `<div>` instead of `<p>`	Chrome	1	`execCommand('defaultParagraphSeparator', false, 'p')` on init
`Enter` key creates `<p><br></p>` with extra `<br>`	Firefox	1	Strip trailing `<br>` inside empty `<p>` after Enter
`Backspace` at start of block merges into previous incorrectly	Safari	4.5	Custom `keydown` handler for Backspace at offset 0, merge blocks manually (owned by Block Editing Semantics)
`Tab` key moves focus away from editor	All	1	`preventDefault()` on Tab inside contenteditable, handle indent manually
Ctrl vs Cmd keyboard shortcuts	Mac Safari/Chrome	4	Detect `event.metaKey` (Mac) alongside `event.ctrlKey` for all shortcuts
`event.key` returns different values for same key	IE-era Edge	4	Normalize key values: check both `event.key` and `event.keyCode` as fallback

Clipboard

Problem	Browser	Phase	Solution
`navigator.clipboard.readText()` requires explicit permission prompt	Chrome/Edge	3	Fall back to `ClipboardEvent.clipboardData` when permission denied
`navigator.clipboard` entirely unavailable on HTTP (non-HTTPS)	All	3	Detect `isSecureContext`, fall back to `execCommand('paste')` on HTTP
`clipboardData.getData('text/html')` returns empty on iOS Safari	Safari iOS	12	Fall back to `text/plain`, insert as plain text
Pasting image from clipboard not supported	Firefox	9	Detect via `clipboardData.items` type check, show "not supported" gracefully
`execCommand('copy')` silently fails in some contexts	Safari	3	Wrap in user-gesture handler, always called inside `click` or `keydown` handler

contenteditable Behavior

Problem	Browser	Phase	Solution
`spellcheck` attribute causes layout reflows on every keystroke	Chrome	1	Set `spellcheck="false"` by default, expose as config option
`contenteditable` ignores `white-space: pre-wrap` on paste	Safari	12	Strip `\r` carriage returns from pasted plain text
`<br>` at end of every block element added automatically	Firefox	1	Normalize: strip `<br>` that is the sole child of a non-empty block
Nested `contenteditable="false"` islands (e.g. image captions) lose focus incorrectly	Chrome	9	Use `mousedown` + `preventDefault` on islands, manage focus manually
`document.execCommand('bold')` wraps in `<b>` not `<strong>`	All	4	Post-process: replace all `<b>` → `<strong>`, `<i>` → `<em>` after execCommand
`document.execCommand('formatBlock', false, 'h1')` fails inside list items	Firefox	4	Detect list context, exit list first, then apply block format
`queryCommandState('bold')` returns false inside nested bold	Safari	4	Walk DOM manually up to editor root to detect bold state

CSS & Layout

Problem	Browser	Phase	Solution
`position: sticky` toolbar flickers on scroll in Safari	Safari	7	Use `-webkit-sticky`, add `will-change: transform` on sticky element
CSS custom properties not updated in Shadow DOM	All	15	Editor does not use Shadow DOM; all CSS scoped via class prefix instead
`caret-color` not respected in older Edge	Edge legacy	15	Set both `caret-color` and `color` for caret visibility fallback
`resize: vertical` on editor container broken on iOS	Safari iOS	13	Disable CSS resize on touch devices, use JS drag handle only
Scrollbar width differs across OS causing layout shifts	Win/Mac/Linux	7	Account for scrollbar width in toolbar overflow calculations
`outline: none` on contenteditable hides focus indicator	All	14	Always replace `outline: none` with a custom visible focus style

Mobile & Touch

Problem	Browser	Phase	Solution
Virtual keyboard shrinks `window.innerHeight` but not `100vh`	Safari iOS	14	Use `window.visualViewport.height` instead of `innerHeight`
Selection handles on iOS render outside editor container	Safari iOS	3	`overflow: hidden` on editor breaks handles — use `overflow: visible` with clip via parent
`touchend` fires `click` with 300ms delay	Older Android	14	Add `touch-action: manipulation` to all interactive elements
Long-press triggers browser's native context menu before ours	iOS	14	`preventDefault()` on `contextmenu` event, `-webkit-user-select: none` on toolbar
Pinch-zoom inside editor breaks layout on re-zoom-out	iOS/Android	14	`touch-action: pan-x pan-y` on editor, disable pinch-zoom only within content area

Obstacles & How We Handle Them

Problem	Phase	Solution
Safari selection API differences	3	Normalize in SelectionManager, Playwright tests on Safari
IME / composition (CJK input)	1	`isComposing` guard + `compositionend` handler, freeze model during composition
execCommand creates `<b>` / `<i>` instead of `<strong>` / `<em>`	4	Post-process output, replace legacy tags after every execCommand
execCommand deprecation edge cases	4	Use for basic formatting, manual DOM manipulation for complex ops
XSS via `javascript:` / `data:` URIs	2	Block at sanitizer layer, block again at each plugin insert point
CSS injection via style attributes	2	Whitelist-only style values, strip `url()` / `expression()` patterns
Word HTML paste garbage	12	Full sanitizer + MSO-specific cleanup rules
Toolbar click steals focus	7	Save range on `mousedown` (before `blur`), restore before command executes
Cursor restore after undo	5	TreeWalker-based position stored in every snapshot
Mobile virtual keyboard viewport shift	14	`visualViewport` API, scroll editor into view on resize
Table keyboard navigation	11	Dedicated keydown handler active only when cursor is inside table
Large document performance	2+	Debounced serialization, no unnecessary full re-renders
Cross-browser br vs p behavior	1	`defaultParagraphSeparator` on init, normalize on every input
Focus trap in modals	6	Capture Tab keydown, cycle through focusable elements within modal
Pinch-zoom inside editor on iOS	14	`touch-action: pan-x pan-y` on editor content area
Shift+Enter vs Enter ambiguity	1	Explicit keydown handler: Shift+Enter → `<br>`, Enter → new `<p>`
Ctrl shortcuts on Mac vs Windows	4	Check both `event.ctrlKey` and `event.metaKey` on every shortcut handler
iframe sandbox value for embeds	13	YouTube/Vimeo: `sandbox="allow-scripts allow-popups"` — never `allow-same-origin` (opens XSS)
`target="_blank"` without `rel="noopener"`	10	Auto-apply `rel="noopener noreferrer"` whenever `target="_blank"` is set
Collaboration undo conflict	19	Local undo and OT are incompatible without design — remote changes must be excluded from local undo stack
`navigator.clipboard` permission timing	3	Call `permissions.query({name:'clipboard-read'})` before `clipboard.read()` to prompt at a predictable moment
Async callbacks after destroy	all	Every async path (upload, autosave, AI stream) must guard with `editor.isDestroyed()` before calling any editor method

Testing Strategy

Unit tests (Vitest): every utility function, every command, all state mutations
Integration tests (Vitest + jsdom): editor mount/destroy, state changes, command sequences
Browser tests (Playwright): selection, keyboard shortcuts, paste, all cross-browser
Accessibility tests (Playwright + axe-core rules): ARIA, keyboard nav, screen reader compatibility
Visual tests: toolbar state, theme rendering, dark mode
Security tests: XSS payload battery, javascript:/data: URI probes, <base> injection, inline SVG injection, mXSS round-trip test, prototype pollution via config fuzz
Sanitizer fuzz tests: random/semi-random HTML input, assert no <script> in output, assert output is valid HTML, assert no throws
Snapshot tests: sequence of operations → assert exact getHTML() output matches stored snapshot (primary regression mechanism for output format)
Performance benchmarks (CI gates): selectionchange handler ≤ 16ms; getHTML() on 10,000-word doc ≤ 50ms; editor mount ≤ 100ms
Plugin isolation tests: use the plugin test harness (Phase 8) to unit-test each plugin independently
Rule: no phase is complete until browser tests pass on Chrome, Edge, Firefox, Safari (desktop), Safari iOS, and Android Chrome

Coding Standards

Pure JavaScript — ES2020, no TypeScript in source (.d.ts files hand-written separately)
No classes forced where functions suffice
No global state — everything scoped to editor instance
Every module exports a single clear interface
No comments explaining what code does — only why when non-obvious
File size limit: 300 lines, then split
Z-index layering contract (lowest → highest): editor content (1) → sticky toolbar (10) → inline bubble toolbar (100) → tooltips (200) → context menus (300) → modals (400) → all values defined as CSS custom properties (--oe-z-toolbar, --oe-z-tooltip, etc.) so host pages can override without conflicts

Versioning

0.x.x  — development phases (0–15, incl. 4.5 + 7.5), API unstable
1.0.0  — phases 0–16 + 16.5 + 16.6 complete (Public API frozen, hardened, modern UX), npm published
1.x.x  — phases 17–18 (npm + wrappers), bug fixes, no breaking changes
2.0.0  — breaking API changes only (rare, announced in advance)

editor.reset() — emergency recovery: wipes internal state, re-renders from last clean snapshot, fires error event with context. Available from Phase 1 onward.

License

Core: MIT Premium packages: Commercial license required

Built from scratch. Zero dependencies. Runs forever.

Name		Name	Last commit message	Last commit date
Latest commit History 20 Commits
.claude		.claude
.github/workflows		.github/workflows
apps/playground		apps/playground
docs		docs
packages		packages
premium		premium
scripts		scripts
.gitignore		.gitignore
.nvmrc		.nvmrc
CHANGELOG.md		CHANGELOG.md
LICENSE		LICENSE
README.md		README.md
SECURITY.md		SECURITY.md
eslint.config.js		eslint.config.js
netlify.toml		netlify.toml
package.json		package.json
pnpm-lock.yaml		pnpm-lock.yaml
pnpm-workspace.yaml		pnpm-workspace.yaml

Folders and files

Latest commit

History

Repository files navigation

Open Editor

Philosophy

Quickstart

Architecture

Canonical DOM Shape

Folder Structure

Status

Implemented vs. Planned

Development Phases

PHASE 0 — Project Foundation

PHASE 1 — Core Engine

PHASE 2 — State Manager

PHASE 3 — Selection Engine

PHASE 4 — Command System

PHASE 4.5 — Block Editing Semantics

PHASE 5 — History Engine

PHASE 6 — Shared UI System

PHASE 7 — Toolbar System

PHASE 7.5 — Playwright Verification Gate

PHASE 8 — Plugin System

PHASE 9 — Image Plugin

PHASE 10 — Link Plugin

PHASE 11 — Table Plugin

PHASE 12 — Paste Engine

PHASE 13 — Content Plugins

PHASE 14 — Accessibility & Mobile

PHASE 15 — Theme System

PHASE 16 — Public API

PHASE 16.5 — Production Hardening

PHASE 16.6 — Modern Editing UX

PHASE 16.7 — Competitive Parity Pass

PHASE 17 — npm Publishing

PHASE 17.5 — Free-Tier Competitive Sweep

PHASE 18 — Framework Wrappers

PHASE 19 — Premium Layer

PHASE 20 — Engineering Moats (ongoing, post-launch)

PHASE 21 — Web Platform, Part 1: Public Site + Playground (NEW repo: open-editor-web)

PHASE 22 — Entitlements Foundation (client-side, in this repo)

PHASE 23 — Web Platform, Part 2: Admin Panel + License Service (same open-editor-web repo)

PHASE 24 — Web Platform, Part 3: Commerce & Customer Portal (same open-editor-web repo)

PHASE 25 — Distribution: openeditors CLI + name migration (decided 2026-07-15)

Browser Support

Cross-Browser Problem Map

Selection & Cursor

Input & Keyboard

Clipboard

contenteditable Behavior

CSS & Layout

Mobile & Touch

Obstacles & How We Handle Them

Testing Strategy

Coding Standards

Versioning

License

open-editor

About

Resources

Security policy

Stars

Watchers

Forks

Releases

Packages

Contributors

Languages

PHASE 21 — Web Platform, Part 1: Public Site + Playground (NEW repo: `open-editor-web`)

PHASE 23 — Web Platform, Part 2: Admin Panel + License Service (same `open-editor-web` repo)

PHASE 24 — Web Platform, Part 3: Commerce & Customer Portal (same `open-editor-web` repo)

PHASE 25 — Distribution: `openeditors` CLI + name migration (decided 2026-07-15)