Validation record

Continuous editing milestone — workspace, 2026-09-13

The current local core candidate passed the shared continuous suite in all nine host demos (16 host/mode combinations, plus React standalone). The complete suite has 17 cases / 532 checkpoints. It verifies nested input, selection wrapping, radical conversion, matrix entry, multiple Undo/Redo sequences, copy/delete/paste history, Apply/Cancel, save/reload/restore, reopened editing and active-draft read-only transitions. Inline hosts also verify prose continuation and Enter completion.

Host-chain evidence (local evidence). The core validation record contains the other editing and geometry suites. This run uses workspace source; it does not replace the dated packed-consumer checks below or prove npm publication.

Editor.js has no configured host history and cannot save while read-only; saved data is compared after re-enabling. Read-only changes are triggered without pointer blur to isolate them from intentional Apply-on-blur behavior. TinyMCE uses its inline host configuration, CKEditor uses ClassicEditor, and Gutenberg uses the standalone provider. Other configurations, actual OS clipboard/IME and other browser engines remain outside this run.

Development preview. Latest recorded run: 2026-09-13. This record covers the environments and workflows below, not a cross-browser or commercial compatibility guarantee.

Site consumption of packed plugins — 2026-09-09

Copied the integration app, shared site navigation and TypeScript configuration into a temporary consumer outside the repository. Extracted the ten reviewed npm archives from batch release-QoRuhz, verified their SHA-256 hashes, and used their published exports without workspace aliases. Only third-party SDK dependencies were linked from the local installation. The private integrations package was not installed, and no math implementation TypeScript was present in the archives.

The independent copy uses the same JSX configuration as the app. The temporary development server allows the linked SDK font directory explicitly; neither adjustment changes package code. The production check served the emitted static assets through an ordinary HTTP server. These are locally prepared archives, not a fresh registry installation or a deployed website. Versions and publication state were not changed. Compact evidence is stored in output/math-plugin-site-checks/2026-09-09-packed-consumer/evidence.json.

Per-plugin source ownership — workspace, 2026-09-09

All nine public plugins now own their implementation, tests, styles and TypeScript configuration. The private common package contains only data, draft-field UI, messages and common styles. Tiptap depends on the public ProseMirror plugin. The demo and WordPress entry points import the public packages.

The following checks passed for this refactor:

Browser checks used local Chromium. TinyMCE checks wait for the deferred draft opening before interacting with it. The final nine-host run passed after the development server completed dependency prebundling. OS IMEs, Safari, Firefox and screen readers were not re-certified. Workspace exports now point to source; publishConfig overrides point to shipped runtime and declarations. Consumer checks copy local generated dependencies with published manifests, so workspace source cannot satisfy a missing artifact import. The source-ownership Changeset proposes patch releases for the core and nine plugins; these checks did not apply versions or publish.

Scoped host themes — workspace, 2026-09-09

TinyMCE in-place and classic iframe regression checks pass with custom palette, inline-background and primary-action foreground variables. Native/React theme fixtures also cover scoped portals, shared toolbars, live theme switches, per-instance isolation and cleanup. See the core styling guide for CSS ownership and iframe boundaries. User themes do not change stored formula size or serialized data.

Environment

• Tiptap core / StarterKit: 3.31.3
• ProseMirror state: 1.4.4; model: 1.25.11; view: 1.42.3
• Lexical: 0.50.0; Editor.js: 2.31.6; Quill: 2.0.3
• TinyMCE: 8.9.0; CKEditor 5: 48.5.0
• Slate: 0.126.2; slate-react: 0.126.4; slate-history: 0.113.1
• Gutenberg blocks: 15.27.0; block-editor: 17.0.0; data: 10.54.0
• Barocss Math Editor: local 0.2.1 workspace build
• KaTeX preview: 0.16.28, trust: false
• Browser: local Playwright Chromium on macOS

TinyMCE in-place drafts and selection collapse — 2026-09-09 workspace

Core regression: 503 tests; shared integrations: 52 tests. The TinyMCE adapter now honors the default inline editing mode in both inline and classic iframe hosts. The existing external panel tests explicitly select editing: "panel".

The following checks passed against the final workspace build in local Chromium:

These checks reported no page errors. The TinyMCE fixture supplies editor/adapter styles inside the iframe; production consumers must do the same through content_css. Normal serialization uses the adapter's PreProcess hook before AST filtering; bypassing it with no_events: true is not supported while a draft is active. OS IME, Safari/Firefox, touch and accessibility remain separate checks. The nine-host run uses standalone Gutenberg; it does not repeat installed WordPress validation for this change. No version or publication was performed by these checks.

Matrix cell editing — 2026-09-09 workspace

The common field now exposes cell rectangles, shape-checked clipboard operations and full-matrix transpose. The new core APIs do not change any host's stored math attributes. Core regression: 498 tests; integration regression: 52 tests. Both packages and both demo applications passed type checks.

matrix-range-host-check.js passed in local Chromium with zero page errors for Tiptap, ProseMirror, Lexical, Editor.js, TinyMCE, CKEditor, Quill, Slate and standalone Gutenberg. Each host created a 2 × 2 matrix through suggestions, filled its cells, selected/copied and cleared cell contents, restored them through draft Undo, transposed the matrix and applied it. Reopening retained the transposed order. Pasting a copied rectangle followed by Cancel preserved the saved document. One host Undo restored the initial formula where host history was configured; Editor.js has no native document history.

matrix-range-check.js also passed against native and rich React surfaces with nested fractions and a non-square matrix. It verifies actual drag/Shift+click, keyboard expansion, exact cell payloads, rejected size mismatches, anchored TSV growth, transpose with a nested caret and resumed editing. Its clipboard events use DataTransfer, not a system clipboard transfer between applications.

An initial combined run reported a Slate document comparison mismatch. The unchanged isolated Slate workflow passed; the final all-nine run passed after the test waited for the initial host render before capturing its baseline. No Slate adapter fix or established runtime defect is claimed for that first result.

These are workspace changes awaiting release. Installed WordPress, OS IME, Safari/Firefox, touch and screen readers were not re-certified by this run. See the core matrix API contract for paste dimensions, matrix size limits and transient selection metadata.

Native tools and selection — 2026-09-09 workspace

These checks use the rebuilt local core and integration modules, without browser response overrides. The changes await release; package versions were not changed and no npm packages were published during this work.

The browser checks exposed three defects and passed after their fixes. Suggestions could cover compact actions, so the native editor now accepts menuAvoidElements and adapters reserve their action bar. Shared-toolbar focus transfer could temporarily leave activeElement on the document body and commit a draft; the coordinator now respects the explicit focus destination. Quill could lose a native selection after expanding tools because selection-only renders were not reported to the host. The native onRender callback now reports the final DOM/caret state, allowing the existing Quill observer recovery to retain the correct range.

Browser tests target the active math input with input.me-input: an unqualified combobox locator also matches the new matrix/template select controls. Clipboard payload checks use synthetic ClipboardEvent/DataTransfer, and composition checks use synthetic events. They do not certify OS clipboard or real input methods. The visual reference is output/playwright/native-parity-editor-katex.png. Safari/Firefox, touch, assistive technology and arbitrary constrained host layouts remain separate validation work. Installed WordPress was not rerun for this change; the Gutenberg result above uses the local standalone BlockEditorProvider sample.

Historical checks — 2026-09-08

The direct-editing checks caught a real integration issue: native input replacement emits blur without a destination. Treating that as a host exit committed the draft before Cancel. The integration now ignores transient/internal blur and checks the actual destination. The same workflows passed after the fix. The final run of all four browser workflows captured page errors and completed with none. Empty native caret slots also received a DOM Range guard after an exception was found in the browser log; the core patch has a pending Changeset.

Core and ProseMirror checks — 2026-09-09

The following checks passed in local Chromium on macOS. The historical results above remain a record of the earlier implementation; current boundary deletion behavior is covered by the newer checks below.

Synthetic composition events check application guards; they do not validate an OS input method or replace the pending native IME checks.

Historical limitation from this run

Suggestions overlapped compact draft actions at some viewport positions. Those checks dismissed suggestions before clicking Apply, so their passing result did not establish a placement fix. The later native-controls work below reserves the action bar and tests opening More tools without dismissing the selection menu.

Additional host adapters — 2026-09-09

These are local development checks, using real host SDKs and the native math field. Editor.js is a block tool; TinyMCE uses an external explicit-Apply panel. Host placement and the location of the draft editor are different capabilities.

The CKEditor checks found that the model treats null as attribute absence. Storing mathDocument: null as a model attribute caused Apply to fail for LaTeX-only imports. The converter now omits that attribute on creation and removes it for a null update; regression tests exercise both directions. Editor.js's sanitizer also needed an explicit pass-through rule for math strings and model data. Rendering still uses textContent or the host's trusted rendering callback; data preservation does not turn formula text into HTML.

TinyMCE previews now derive their expression from the authoritative model, including when the stored LaTeX fallback differs. A custom renderer receives an empty preview container. Clicking a formula also refocuses the math field after TinyMCE finishes its selection handling, so the next keystroke reaches the draft rather than the host.

Quill initially restored a host document Range over the focused math input after DOM reconciliation. This prevented real keystrokes even though programmatic input filling worked. The adapter now captures the native math caret after rendering and restores it after observer delivery, using DOM selection APIs without overriding Quill internals. Sequential typing and selected replacement are covered explicitly.

The first mixed-host run reported a Quill Cancel mismatch, but the same unchanged workflow passed on a fresh session, as did four isolated Cancel repetitions and block Cancel. HMR timing was suspected but not established; no unverified fix is claimed for that first result.

The new adapters share EN/KO math control messages and accept custom overrides. The host editors' own built-in menus and language packs are configured separately. These checks do not certify OS IME, browser clipboard integration, screen readers, collaboration, or keyboard-boundary parity for every new host.

Slate, Gutenberg and iframe embedding — 2026-09-09

Slate focus restoration needed to wait for pending Slate operations and avoid stealing focus from a newly inserted formula. Gutenberg's continuous setAttributes changes initially merged multiple Apply actions into one undo step. The adapter now dispatches one public updateBlock action per Apply while preserving other attributes and the block identity. The consecutive-Apply browser checks cover this behavior in both the standalone host and actual WordPress.

Iframe testing found that DOM constructors, node creation, selection ranges and default menu placement were using the outer document. Native UI now uses the embedding document; the shared field also listens to accessible same-origin ancestor documents for outside pointer/focus changes and removes those listeners on destroy. This does not claim support for reaching across cross-origin frames.

The WordPress check mounted and activated the same generated plugin directory that is archived in the ZIP. It did not exercise the dashboard upload wizard, WordPress.org distribution, other WordPress/PHP versions, or production hosting. The manifest's WordPress 6.6 / PHP 7.4 loader minimum is not a tested compatibility range. The local author account triggered a WordPress settings-endpoint 403, and the host emitted preload/theme-style notices; these were not plugin asset or JavaScript execution failures. A test fixture initially omitted LaTeX's required escape before &; the corrected \& fixture passed.

Editor and frontend screenshots are saved as output/playwright/wordpress-editor.png and wordpress-frontend.png. The demo production build retains a large-chunk warning from the host SDK bundles. The WordPress plugin build externalizes its host SDKs and does not use that demo bundle.

Unified samples and npm preparation — 2026-09-09

The canonical sample is now /?editor=<host>&lang=<locale>. All nine hosts share one navigation and sample shell; only the selected host is mounted. Old plugins.html links preserve their host, language and mode when redirected.

TinyMCE's preview refresh now runs inside the same undo transaction as the model update. Previously the later preview DOM change could create another undo step after keyboard Apply. The Lexical sample also establishes its initial history baseline before the first edit. These are separate host-history corrections.

Artifact consumer checks use the installed host SDKs and the local public core build as external peers, without linking the private integration package. The core manifest is still 0.2.1 in this workspace; the reviewed version preview is 0.3.0 for core and 0.1.0 for each new plugin. The test does not establish that the required ^0.3.0 core is already available from npm. CKEditor and Gutenberg main modules need a browser; their Node checks cover the shared/data entries and static dependency graph, with host interaction verified separately above.

Preparation produced local 0.0.0 preview tarballs and a release report under output/math-plugin-releases/. No real versions were applied, no packages were published, and no public site was deployed in this run. The current workspace now includes MIT LICENSE files and metadata for all nine plugins and the shared source package. The earlier tarballs predate that update and must be regenerated. Private flags and version preparation remain publication prerequisites. See Publishing the host plugins for the release order.

Re-run

Run the sample at port 5185 after building the public plugins. Unit tests:

pnpm build:math:plugins
pnpm -r --filter '@barocss/math-editor-*' test
pnpm --dir packages/math-editor test

Browser checks are Playwright CLI run-code functions, not Playwright Test specs. With Node 20+ and @playwright/cli available, from the repository root:

mkdir -p output/playwright
npx @playwright/cli -s=math-integrations open 'http://localhost:5185/?lang=en' --headed
npx @playwright/cli -s=math-integrations run-code "$(cat apps/math-integrations/tests/browser-check.js)"
npx @playwright/cli -s=math-integrations run-code "$(cat apps/math-integrations/tests/inline-check.js)"
npx @playwright/cli -s=math-integrations run-code "$(cat apps/math-integrations/tests/host-check.js)"
npx @playwright/cli -s=math-integrations run-code "$(cat apps/math-integrations/tests/typing-check.js)"

Re-run the newer checks in the same browser session (the React check also needs the main demo on port 5184):

check_source=$(mktemp -t math-integrations-check)
for check_name in unified-check vertical-check react-vertical-check shared-boundary-check plugins-check plugins-locale-check quill-typing-check ckeditor-check tinymce-check tinymce-iframe-check slate-check gutenberg-check iframe-field-check; do
  node -e 'const fs = require("node:fs"); process.stdout.write(fs.readFileSync(process.argv[1], "utf8").trimEnd().replace(/;$/, ""));' \
    "apps/math-integrations/tests/$check_name.js" > "$check_source"
  npx @playwright/cli -s=math-integrations run-code "$(cat "$check_source")"
done
rm "$check_source"

The CLI used for this run rejects a trailing semicolon after the supplied function expression. The temporary source above removes only that final semicolon and leaves the checked-in scripts unchanged. When supplying a function manually, omit its trailing semicolon. Use the same normalization for an earlier check if its source triggers this CLI issue.

For wordpress-check.js, first build the WordPress preview ZIP and activate it in a disposable WordPress site at http://127.0.0.1:9400. Open a separate Playwright CLI session and log in as an author without unfiltered_html; then run that file with the same trailing-semicolon normalization. The script publishes a fixture only on that loopback test site. It checks real server persistence, unlike the standalone Gutenberg browser test. Existing drafts in that disposable session may be discarded during navigation.

The clipboard check uses macOS Command shortcuts. Change them for another OS. Inspect CLI errors/results; a script printing its source is not by itself an assertion. The checks throw on failed invariants. Visual artifacts are under output/playwright/.

Still required before customer certification

• Safari/Firefox, mobile and touch; OS-level IME composition (not exercised here).
• Screen reader behavior and a complete keyboard-only accessibility review.
• Complex surrounding documents: tables, lists, nested custom nodes, drag/drop.
• Real collaborative editing sessions and network conflict recovery.
• Additional host versions, external sanitizer recipes, Markdown conversion hooks.
• Suggestion-menu and compact-action placement at different viewport positions.
• Deployment, product licensing, billing and support arrangements.

The operand/size browser check covers both Tiptap and ProseMirror: 4ab to 4\left|ab\right|, suggestion scroll position after entering 4, cancelling native dragstart during editing, and committing/undoing a size change. Core regressions additionally check all 30 wrapping structures, their destination slots, adjacent text preservation, and Undo.

Shared editing utilities — workspace, 2026-09-09

The core now supplies token-level active inputs, explicit LaTeX paste, recent/favorite symbol/template preferences and contextual presentation settings. Both the ProseMirror NodeView and the shared field reserve utility-form Ctrl/Cmd+Enter before host Apply handling.

latex-paste-host-check.js passed all 16 supported host/placement combinations across Tiptap, ProseMirror, Lexical, Editor.js, TinyMCE, CKEditor, Quill, Slate and standalone Gutenberg. Insertion keeps the draft open and the host data unchanged; typing continues after the fragment and Cancel preserves the original. host-composition-check.js also passed all 16 combinations. The Quill focused typing/composition fixtures and native selection regression pass. Core: 548 unit tests; integrations: 52. Both demo builds and all four type checks pass.

See the core utility API. These results use local Chromium, not OS IME or broad browser certification. Updated source and pending Changesets require new release artifacts before publication.

Selection suggestion navigation — workspace, 2026-09-09

selection-suggestions-check.js passed in Chromium for rich React and all nine host adapters. Shift+arrow selection and native mouse-drag selection retain content while Up/Down navigates the wrapping menu. Enter wraps the selected content and restores input focus. Alt+Down remains an alias. No page errors were reported. These are local-source checks, not a publication claim.

EDIT-019 Tiptap and ProseMirror — workspace, 2026-09-10

• Run: 2026-09-09T22-39-51-097Z, stable source fingerprint.
• Report (local evidence) and checkpoints and hashes (local evidence).
• 7 targets PASS / 205 checkpoints: React block (28), Quill block/inline (29/30), Tiptap block/inline (29/30), ProseMirror block/inline (29/30).
• Chromium 152 on macOS, English UI, workspace source. The extended runner hashes both newly covered plugin sources and package metadata.
• Each target passes the existing continuous formula chain. Integrated hosts additionally check Apply/host Undo/Redo, Save/reload/Restore, re-edit/Cancel, retained formula data and unchanged prose/container structure. Inline targets check Enter commit, right-boundary exit, exact prose position and host Undo.
• Initial integrated run 2026-09-09T22-36-38-459Z: six PASS, Tiptap inline FAIL. A quick prose edit after Restore shared the restored document's history event; Undo removed both. The sample now brackets setContent with closeHistory transactions, keeping the replacement and subsequent typing separate.
• Corrected run 2026-09-09T22-38-26-544Z: seven PASS. The final run above repeats all seven targets with the final runner documentation and source hashes.
• Integration-demo TypeScript and production build pass. Existing large-chunk build warnings remain. Test source formatting passes. Core/plugin runtime code was unchanged; the fix belongs to the Tiptap demo's restoration callback.
• Remaining: Lexical, Editor.js, TinyMCE, CKEditor, Slate and Gutenberg; native OS IME/clipboard, other browser engines, touch, accessibility and performance.

EDIT-019 Lexical — workspace, 2026-09-10

• Run: 2026-09-09T23-08-15-353Z, stable source fingerprint.
• Report (local evidence) and checkpoints and hashes (local evidence).
• 9 targets PASS / 264 checkpoints: React block (28), Quill block/inline (29/30), Tiptap block/inline (29/30), ProseMirror block/inline (29/30), Lexical block/inline (29/30).
• Chromium 152 on macOS, English UI, workspace source. Fingerprints now include the Lexical plugin source and package metadata.
• Lexical passes the full nested editing and two history chains, Apply as one host Undo event, Redo, Save/reload/Restore, re-edit and Cancel. Inline also passes Enter commit without a new paragraph, right-boundary exit, focus return, typing immediately after the formula and host Undo.
• Host checks read Lexical serialized state and retain container boundaries and formula atoms. Drafts must not change saved host state. Restoration must match the complete saved JSON; math rendering alone is not the persistence check.
• The initial run 2026-09-09T23-06-35-494Z reached Save/Restore in both Lexical modes but used an incorrect locator for reopening. Lexical uses a mounted .bme-lexical-node widget; data-barocss-math belongs to its HTML export. The fixture now locates its live widget. No product code change was needed.
• Runner formatting passes. This change only extends tests and documentation; no new build, package publication or rendering audit was required.
• Next: Editor.js, TinyMCE, CKEditor, Slate and Gutenberg. Native OS IME/clipboard, other browser engines, touch, accessibility and performance remain outside this run.

EDIT-019 Editor.js — workspace, 2026-09-10

• Run: 2026-09-09T23-25-26-845Z, stable source fingerprint.
• Report (local evidence) and checkpoints and hashes (local evidence).
• 10 targets PASS / 293 checkpoints: React block (28), Quill/Tiptap/ ProseMirror/Lexical block and inline (29/30 each), Editor.js block (29).
• Chromium 152 on macOS, English UI, workspace source. Fingerprints include Editor.js plugin source and package metadata.
• Editor.js passes nested fraction/root/matrix editing, suggestion selection, two uninterrupted formula Undo/Redo chains, empty-root deletion/restoration, Apply, Save/reload/Restore, re-edit and Cancel. Draft checks confirm saved host data stays unchanged until Apply; prose blocks and block order remain intact.
• Async save() comparisons exclude only the generated time field. Block IDs, saved model data, paragraph data and version remain in persistence assertions.
• Editor.js host Undo/Redo is not covered: the demo has no document history integration. The runner records this limitation in hostHistory; it retains the mandatory host Undo/Redo assertions for other configured hosts. Editor.js inline mode is outside the block tool's contract.
• Test-source formatting passes. Only the runner, fixture and documentation changed; no runtime fix, build, publication or new rendering audit was needed.
• Next: TinyMCE, CKEditor, Slate and Gutenberg. Native OS IME/clipboard, other browser engines, touch, accessibility and performance remain separate work.

EDIT-019 TinyMCE — workspace, 2026-09-10

• Run: 2026-09-09T23-39-57-339Z, stable source fingerprint.
• Report (local evidence) and checkpoints and hashes (local evidence).
• 12 targets PASS / 352 checkpoints: React block (28), Quill/Tiptap/ ProseMirror/Lexical/TinyMCE block and inline (29/30 each), Editor.js block (29).
• Chromium 152 on macOS, English UI, workspace source. TinyMCE 8.9.0 uses inline: true for its host. Both math modes are covered; classic iframe mode is not covered by this run. Fingerprints include TinyMCE source and metadata.
• TinyMCE passes the sustained fraction/root/matrix chain, formula history, draft isolation, one host Undo/Redo for Apply, Save/reload/Restore, re-edit and Cancel. Inline also passes Enter commit, right-boundary exit, focus return, typing immediately after the formula and host Undo.
• The fixture applies and reopens an empty atom before the chain because TinyMCE inserts on Apply. This exposed a real bug: the empty preview renderer returned no visible content, leaving no click target. The adapter now shows the existing localized empty-formula message and skips the renderer for empty LaTeX. Serialized content stays empty; the test checks the label does not leak into HTML.
• HTML comparisons retain the complete serialized document. A detached parser reads prose and element boundaries for caret checks. Live locators exclude TinyMCE's .mce-offscreen-selection clone inside the editable body.
• Diagnostic run 2026-09-09T23-38-20-112Z confirmed that a reported prose Undo failure was in the fixture: saved and actual HTML were identical, but building the expected prose result had mutated the saved units array. The fixture now copies that array. No timing wait or product history change is used to pass it.
• TinyMCE package TypeScript, two unit tests, build and changed-source formatting pass. Package-local build also exposed a metafile path check using the wrong working directory. The build now sets esbuild's working directory to the repo root; the normal package build command succeeds with its dependency checks intact.
• Patch changeset: .changeset/tiny-math-empty-preview.md. No package was published.
• Remaining: CKEditor, Slate, Gutenberg, TinyMCE iframe mode, native OS IME/clipboard and other browser/input environments. Editor.js document history remains unverified because its demo has no host history integration.

EDIT-019 CKEditor — workspace, 2026-09-10

• Run: 2026-09-09T23-44-59-263Z, stable source fingerprint.
• Report (local evidence) and checkpoints and hashes (local evidence).
• 14 targets PASS / 411 checkpoints: React block (28), Quill/Tiptap/ ProseMirror/Lexical/TinyMCE/CKEditor block and inline (29/30 each), Editor.js block (29).
• Chromium 152 on macOS, English UI, workspace source. CKEditor 48.5.0 uses the local ClassicEditor demo. Fingerprints include CKEditor plugin source and package metadata. This run does not cover other CKEditor builds or collaboration.
• CKEditor passes the sustained fraction/root/matrix chain, keyboard suggestion selection, two formula Undo/Redo chains, empty-root deletion/restoration, unchanged host data during drafts, Apply as one host Undo event and host Redo.
• Save/reload/Restore retains the complete serialized HTML and editable math structure. Re-edit and Cancel leave that HTML unchanged. Inline also passes Enter commit without another paragraph, Right-arrow exit, focus return, prose input immediately after the formula and host Undo.
• The fixture reuses the detached HTML parser for prose/container checks and copies parsed units when constructing expectations. Full saved-state equality remains required for history and persistence checks.
• Test-source formatting passes. Only tests and documentation changed in this extension; no runtime fix, additional build or package publication was needed.
• Next: Slate and Gutenberg. TinyMCE iframe hosts, other CKEditor builds, native OS IME/clipboard and other browser/input environments remain separate targets. Editor.js document history is still outside its demo's configuration.

EDIT-019 all integration demos — workspace, 2026-09-10

• Run: 2026-09-09T23-55-26-302Z, stable source fingerprint.
• Report (local evidence) and checkpoints and hashes (local evidence).
• 17 targets PASS / 499 checkpoints, covering all nine integration demos plus standalone React block. Chromium 152 on macOS, English UI, workspace source.

• Slate passes the sustained nested editing chain, two formula Undo/Redo chains, Apply as one host history event, Save/reload/Restore, re-edit and Cancel. Inline also passes Enter commit, Right-arrow exit, host focus, exact prose insertion position and host Undo. Comparisons retain the saved descendant array and formula objects; prose checks also preserve paragraph boundaries.
• Gutenberg passes the same block chain and provider host Undo/Redo. Full saved HTML equality includes WordPress comments and encoded math data. A separate detached DOM comparison checks prose and block order; comments are not prose.
• Both new hosts keep saved document data unchanged while editing a draft. Restore reproduces the full saved state and reopens the same editable model.
• Fingerprints now include Slate and Gutenberg source/package metadata, as well as the previously covered hosts, core, shared helpers, demos and test runner.
• Formatting passes. This extension changed only tests and documentation; no runtime fix, new build or publication was needed.
• This run covers local demo configurations. It does not replace the separate WordPress admin/plugin ZIP checks. TinyMCE iframe, other CKEditor builds, collaboration, native OS IME/clipboard, Firefox/WebKit, touch, accessibility and performance remain separate targets. Editor.js/Gutenberg are block tools; no inline mode is claimed for them.