Changelog

Saved rich text is segments — Rich fields in every host save now hold a RichText segment array instead of an HTML string.

• Covers save(), onSave, BlockAPI.save(), onChange saves, getBlockData() and importMarkdown(), also with collaboration and dataModel: 'legacy'. getBlockData() returns a new .data object each call.
• Input still accepts HTML. Read a field with richTextToHtml, and convert stored documents with migrateToRichText from @bloklabs/core/migrate.
• ParagraphData and its siblings now type text as RichText. Tool subclasses use the new ParagraphToolData and siblings, with text: string.

HTML and Markdown importers return segments — htmlToBlocks, markdownToBlocks, their WithReport forms and the .NET FromHtmlAsync and FromMarkdownAsync return rich data.text as segments.

• Old: "a <b>b</b>". New: [{ text: 'a ' }, { text: 'b', marks: { bold: true } }].
• Pass the output to the editor or the view as is, or read a field as HTML with richTextToHtml.

Collaboration speaks format 2 — Rooms store rich text as formatted text, so the editor and the sync server must upgrade together.

• The client ends a format-1 room with unsupported-format, drops format-1 offline copies and never sends format-1 outbox rows.
• Blok.Server migrates a format-1 room once on open, under a new lineage. A third-party sync server must announce format 2 and mint a new lineage at epoch + 1 when it migrates.
• The write-back PUT to your document endpoint now carries segments. List custom rich fields in --rich-text-fields or options.RichTextFields.

Saved output keeps content it used to drop — Some documents now save blocks that earlier versions lost.

• With dataModel: 'legacy', a legacy list keeps every item and saves in the 'auto' shape: one list block per root item, checklists as style: 'checklist'.
• A table child that no cell names, with content, now saves at the root after its table. Empty ones are still removed.
• Video Loop Off now saves loop: false. Treat false as off instead of checking for a missing loop.

Tab sync is on by default — Tabs of one browser showing the same document now share one live copy, and only the leader tab saves.

• Only the tab the user works in calls onSave and writes through persistence. Set tabSync: false to keep the old per-tab saving.
• save() output now carries a top-level id, the document record id. Allow the new key if you compare OutputData strictly.
• Locale, theme mode and width now follow across tabs. Set tabSync: { settings: false } to keep them per tab.

Toggle open state is no longer saved — Toggles and toggle headings keep their open state per browser, and load collapsed by default.

• isOpen is no longer read from input, written by save(), or part of ToggleData and HeaderData.
• Expanding or collapsing no longer fires a document change.

Blocks API keeps the tree in order — Placement calls now give a block the parent its position implies, and loaded data is reordered depth-first.

• blocks.insert() at an index inside a container makes the block that container's child. Insert after the whole subtree, or call setBlockParent(id, null) afterwards.
• blocks.setBlockParent() moves the block and its subtree to the end of the new parent's subtree, or just after the subtree it left. Re-read indexes after reparenting. blocks.insertInsideParent() clamps its index into the parent's subtree.
• Block.isEmpty is true for empty toggles, toggle headings, list items, checklist items and code blocks, and false for any block with children.

Two API calls now refuse instead of acting — blocks.convert() can reject, and undo or redo do nothing while read-only.

• blocks.convert() rejects when a peer is editing the block, where it used to resolve and could overwrite their text. Await it and handle the rejection, or retry later.
• history.undo() and history.redo() are no-ops in read-only mode. Call readOnly.set(false) first.

Markdown and HTML output changed — Exports keep line breaks, table cells, quote captions and legacy blocks, so their text differs.

• Markdown writes <br> as a hard break, escapes \*, \[, \# and \<, writes equations as $…$ and adds :---: alignment. Use markdownToBlocks instead of custom regexes.
• importMarkdown reads GitHub alerts (> [!NOTE]) as callout blocks, not quote. A host without the callout tool should map them.
• Legacy warning, linkTool, raw, attaches and toggleList blocks now render in /view. A legacy quote caption exports as an attribution line inside the quote. Update snapshot tests and warning-text matches.

HTML table import reads more structure — htmlToBlocks reads cell colors, placement and widths, and treats a heading column more strictly.

• Rows that all start with <th>, without <thead>, now import a heading column only, not also a heading row.
• Cells carry color, textColor and placement from inline style. blocksToHtml can write data-blok-col-widths and data-blok-stretched.

Loading skeleton is on by default — The editor shows a skeleton while persistence.load() runs or until the first collaboration sync.

• When load() takes over 150 ms, isReady, onReady and autofocus resolve after the skeleton hands off, up to about 0.9 s later.
• The wrapper carries aria-busy and an overlay child while loading.
• Pass loader: false to keep the old timing and blank boot.

Blok owns Cmd/Ctrl+F — Cmd/Ctrl+F inside an editor opens Blok's find bar, not the browser's.

• This also applies on the page body when the page has one editor.
• Pass find: false to keep the browser's find.

Hints wait for hover — api.tooltip.show and api.tooltip.onHover never show a hint at once, and focus no longer opens one.

• The default delay is 500 ms, and any delay below 300 ms becomes 300 ms.
• For an always-visible label, render it yourself and set an aria-label for keyboard users.

contentAlign follows the reading direction — In an RTL editor, 'left' and 'right' now mean the start and end of the line.

• The default 'left' now puts an RTL content column on the right. LTR editors are unchanged.
• To keep the old placement in RTL, swap 'left' and 'right'.

Gray selected states and one focus ring — Default token values changed so selected and active states are gray and focus rings use one blue token.

• Now gray: --blok-icon-active-bg, --blok-popover-icon-active-bg, --blok-item-focus-bg, --blok-item-focus-shadow and --blok-database-card-border-active. --blok-icon-active-text is primary ink, and --blok-audio-bar-head no longer mixes in the accent.
• Focus rings are 2px --blok-focus-ring, and --blok-video-focus-ring defaults to it. The light --blok-table-heading-bg is #f7f6f3, not #f9fafb.
• --blok-search-input-bg, --blok-search-input-border and --blok-search-input-focus-border no longer style search fields; override --blok-item-hover-bg and --blok-popover-border. Set the old values in style.tokens to keep the old look.

Old radius tokens and IconMarker removed — The unordered radius scale, --blok-audio-radius and the IconMarker icon are gone.

• --blok-radius-xs → --blok-radius-4, -md → --blok-radius-control, -lg → --blok-radius-12, -xl → --blok-radius-16, -md-plus → --blok-radius-8, -hairline → --blok-radius-notch, -none → 0, -sm → a role token.
• Replace --blok-audio-radius with --blok-radius-block or --blok-radius-control.
• Replace IconMarker from @bloklabs/core/icons with IconPaintRoller.

Mermaid 12 renders code-block diagrams — Mermaid previews use ELK layout and mermaid 12's new look, so diagrams change layout and color.

• Previews need Safari 17.4+, Chrome 117+ or Firefox 119+. Older browsers show an error instead of the diagram.
• Saved data is unchanged, and there is no option yet to restore the old look.

defineBlokSchema uses the editor's inline tool order — Inline sanitizer rules now compose in canonical editor order, not inlineToolbar or registration order.

• If two inline tools have conflicting rules, check which one wins now.

Blok.Server contract changes — Custom IBlokDocumentConverter implementations need new members, and /edit reads If-Match.

• Implement GetPageIndexAsync, RemapPageDocumentAsync and the page-aware ToHtmlAsync and ToMarkdownAsync overloads, for example by forwarding to BlokDocuments.Create().
• POST /sync/{doc}/edit with an If-Match header now gets 400, 412 or 428 instead of 204. Leave it out unless you want the precondition.
• Collaboration document IDs with literal or encoded backslashes are rejected. Rename them first.

Page block — A Page block points at a sub-page your app owns, showing its icon and title and opening it through your host.

• Configure create, resolve, href and open to connect it to your pages.
• create may return { pageId } to use your backend's id instead of Blok's.
• Pass rename, setIcon and peek to show Rename, Edit icon and side peek in the block menu.

Tabs block — A Notion-style tabs block holds tab children, each with a title, optional emoji and its own child blocks.

• Drop a block onto a tab's pill to move it into that tab.
• The open tab is per-editor UI state and is never saved.
• Markdown, HTML, plain text and Notion paste all handle tabs.

Table of contents block — A table_of_contents block lists the page's headings live, indented by depth, with click and keyboard jumps.

• blocksToHtml renders it as a <nav> of links to the saved headings.

Find and replace — Cmd/Ctrl+F opens a Notion-style find bar with match case, whole word and Replace / Replace all.

• Matching ignores case, accents, curly quotes and dash kinds.
• Replacements preview in the text before you apply them.
• Set find: { placement, offset } to choose where the bar sits.

Live sync between browser tabs — Tabs of one browser showing the same document stay in sync live, with no server.

• Set documentId when your app copies documents or serves every document at one path.

Loading skeleton — Placeholder rows show while persistence.load() or the first collaboration sync is pending, then hand off to the real blocks.

• Choose the rows with loader: { skeleton } and the wait before showing with loader: { delay }.

Image darkroom — The image editor now crops, rotates, flips, straightens, adjusts brightness, contrast and saturation, and applies filters.

• Every edit is non-destructive: saved as data and applied when the image is drawn.
• Filters come with a strength slider.
• filters in the image config picks, orders or adds looks, and [] hides the Filters tab.

Image markup — A Markup tab draws on photos with a pen and highlighter, adds text, and places shapes.

• Marks turn and mirror with the photo.
• Marks are saved in data.markup.

Failed image notices — Blok tells the user when an image fails to upload or load, and before they leave with lost uploads.

• Each failed image gets its own toast card with Retry and Show.
• onImageFailure reports failures to your app.
• confirmLeave() shows a Retry / Show / Stay / Leave anyway banner and resolves to a boolean.

Media format variants — Uploaded images and videos can be converted into several formats in the background and rendered best-first.

• Turn it on with media: { formats: { image, video } }.
• Video conversion needs mediabunny: () => import('mediabunny'), which you install yourself.
• Pass convert to use your own converter instead.

Upload error handling — Image, video, audio and file tools take onUploadError to change what a failed upload shows.

• Return a string to show your own message, or false to return the block to its empty state.
• A rejection from your own uploader now reaches the handler as UPLOAD_FAILED with the original error in cause.

Code block redesign — Code blocks gain an optional filename, a highlighted active line, a labelled Copy button and a language picker.

• The picker suggests the detected and recent languages and recolors the code as you browse.
• The new filename field is written to Markdown as a title="name" attribute on the code fence.

Toolbox hover previews — Hovering or arrowing to a toolbox entry shows a small animated drawing of the block with a one-line caption.

• Custom tools can opt in with toolbox.preview, typed by the exported ToolboxPreviewConfig.

Concurrent typing in collaboration — Two people typing in the same paragraph now merge their text instead of one losing a burst.

• Database row titles typed at once also merge.
• A collaborator's selected text is now shaded, not drawn as a lone caret.

Host values in undo history — history.track(key, onChange) keeps a value your app owns, like a page title, in Blok's undo history.

• Cmd+Z walks back through host and block edits in order.
• Collaborators share the value, and it is not part of save().

Personal block state — api.viewState stores per-browser block state that is never saved in the document.

• Toggles and toggle headings keep their open state here, so each reader's choice stays theirs.

Sibling-relative block placement — blocks.insertAt and blocks.moveTo place blocks by parent and sibling instead of a flat index.

• Positions are 'start', 'end', { before } or { after }.
• A bad place throws BlockPlacementError and changes nothing.
• Block events carry parentId, previousSiblingId and an origin of 'local', 'tab' or 'remote'.

Rich text migration tool — @bloklabs/core/migrate converts stored HTML documents to rich-text segments offline, in Node with no DOM.

• Use migrateToRichText, richTextToHtml and richTextToPlainText.
• onLossy reports markup it could not map.

Smarter link field — An empty link field lists your three most recent links, the page's headings, and the link kinds it accepts.

• Picking a heading links #<block id>, which survives a heading rename.
• Set link.unfurl to show page titles for recent links, or let server fill it in.

Paste improvements — Pasted links and spreadsheets keep more of what you meant.

• A URL pasted over selected text links that text instead of making a bookmark.
• Excel cell bold, fills, colors and alignment survive paste.
• List your own site's other hostnames in linkPaste.hostAliases so their links skip "Create bookmark".

Notion-style formatting menus — The inline toolbar is a Notion grid card, and text and background colors share one panel.

• "Turn into" is a plain list with a checkmark on the current type, and now works on callouts.
• Click an inline equation to edit it in a one-row menu with a live chip.

Bookmark and embed redesign — Bookmarks frame their cover in a leaning browser window with a favicon address pill.

• Embed empty states draw each provider kind and morph as you type a link.
• Embeds and the link paste menu show brand marks for covered providers.

Media empty and error states — Empty uploaders show a live preview of the block, and failures now look like the media they replace.

• Failed video and audio cards offer a file picker to try again.
• The video settings card shows speed, a speed ruler and a loop switch in one pane.
• Right-click on page, bookmark, embed, file, image and video blocks opens their block menu.

Table alignment picker — Cell alignment picks from nine positions with a live preview of the cell.

• Every row and column now has a stable id, so concurrent moves and deletes land on the right column.

Right-to-left export — blocksToHtml and BlokView take direction: 'ltr' | 'rtl' and stamp each block with its own text direction.

Server and .NET — The Blok server and Blok.Server gain page-aware exports, cross-page moves and C# ticket minting.

• BlokTicket.Create mints ticket passes in C#.
• --collab-journal adds durable /edit receipts for cross-page moves.
• --rich-text-fields lists custom rich-text fields for the standalone host.

Tool author levers — New block tool statics replace per-tool workarounds.

• isLayout and deletesChildren describe layout containers.
• frameRadius rounds the selection fill to the block's frame.
• prepareInsert lets a toolbox insert wait for data, and copyAsLink makes a copy carry a link.

insertMany and insertMarkdown deleted the rest of the document — Both replaced the whole shared document with the batch, so every other block vanished on the next load and for every peer.

• The screen and save() still showed the old blocks, so nothing looked wrong until a reload.

Undo deleted a block someone else had typed in — Undoing your own insert removed the block with the other person's sentence inside it, on both screens.

• Your own characters still go; theirs and the block stay.

A peer's edit swallowed the character you had just typed — A keystroke landing while a peer's change was applied to the same block was dropped on both sides, nested blocks included.

Two people filling one table cell lost a block — Each person's cell block list overwrote the other's, leaving one block orphaned and unreachable.

A full save deleted a key the other person had just added — A key a peer added during the save window, such as an image caption, was removed locally and then on their screen.

Two peers opening an empty document lost a whole paragraph — Both created the first block with the same id, and one person's typing was overwritten.

• Two peers who open the same empty document at the same moment now get two empty paragraphs.

Every collaborative boot added another copy of a table's cells — Converted legacy cells reached the shared document but the table's references did not, so each boot converted them again.

A peer's edit threw your caret to the start of the block — Any remote update to the block you were typing in rebuilt its content and lost your selection.

Tools stayed half-dead after a collaborative boot — Blocks rendered read-only until the first sync never wired their editing when they turned editable.

• Checklist ticks were not saved, code Tab and highlighting did nothing, and toggle placeholders and the database title stopped responding.

The last edit before destroy() never reached onSave — An edit inside the final save window was dropped on teardown, on an i18n repaint and when read-only turned on.

• onSave, persistence.save, Vue update:data and the Angular outputs can now fire once after destroy() or unmount returns.
• With only synchronous tools, the final onSave now runs inside destroy(). onSave can also fire once as read-only turns on.
• Angular [(ngModel)] still misses the final save when any tool saves asynchronously.

Merged table cells lost styling and content — Merge, split, row and column operations dropped header styling, cell colours and alignment, and load deleted blocks left in covered cells.

Merging table cells misbehaved across the menu, reload and undo — The menu offered Merge instead of Split, block order in a merged cell changed on reload, and undoing a split left a ghost paragraph.

• Malformed merge data is now repaired the same way in the editor, read-only mode and the view renderers.

Pasting into an existing table dropped everything around it — Only the pasted table was read; Excel, Google Sheets, LibreOffice and Word formatting was also lost.

• The surrounding content now lands after the table, in order, as one undo step.

Pasted text lost its line breaks — Inline paste glued <br> lines together, and <div>-per-line HTML from Notion, Word, Gmail, Slack and Google Docs became one run.

Copying out of Blok lost bold, block breaks and code lines — Other apps received plain text for bold, merged blocks into one run, and collapsed code lines.

• Marker colours are now written as the light preset colour, since Blok's CSS variables cannot resolve elsewhere.

Stored marks and plain text were stripped on load — Toggles lost bold and underline, sup and sub vanished when that inline tool was off, and media URLs were HTML-escaped.

• Signed URLs containing & broke because they were saved as &.

Legacy callout titles and table cell lists were lost on load — A callout's title was never read and the first save erased it, and lists inside legacy cells were flattened.

Converting text into a callout or a code block lost its lines — Line breaks and bold were stripped, and literal <b> in code turned into real bold.

Host data from blocks.insert reached the page unsanitized — insert, insertAt, insertMany, update and insertInsideParent let handler attributes and javascript: links reach the DOM and peers.

Markdown export could write a script link — href, image src and block URLs were written raw, so javascript: and crafted URLs became live links in unsanitized renderers.

Undoing moves pulled blocks into a toggle — Cmd+Shift+Up/Down moved blocks by a stale index, and undo restored a deleted block in the wrong place.

• A keyboard move is now one undo step.

One table gesture took several undos and left phantom cells — Add-row and add-column drags split into extra steps, and added cells survived undo.

Toggles vanished, stuck or became columns when dragged — A block dropped below a collapsed toggle holding an open one was swallowed and hidden.

Text nested under a toggle child escaped the toggle — Collapsing the toggle left it visible, and inside a callout it rendered outside the box.

• React, Vue and Angular containers mount these nested lines too.

Backspace could not merge a block that starts with bold, italic or a link — After Enter inside bold, the two halves could never be joined again.

An image's "…" menu deleted a different block — The menu opened for the block holding the caret, so Delete removed that block instead of the image.

A submenu stayed open after the pointer left — Its row stayed highlighted forever, and inline toolbar submenus slid under a fixed host header.

An RTL editor laid out left-to-right in production — The build lowered logical CSS into rules keyed on the page's lang, so an RTL editor on an English page broke.

RTL editing put controls and keys on the wrong side — Block controls covered the text, drag-to-nest nested almost every drop, and arrows stuck at block edges.

• Popovers and submenus now open toward the inline end with mirrored chevrons and keys.

Blok.Server dropped edits held only in the working copy — A host-supplied journal or S3 working copy lost them when the journal started.

• Blok-Doc-Lineage, Blok-Doc-Sequence and ETag are now exposed to browsers for If-Match retries.

Yjs 13.6.33 and lib0 0.2.119, deduplicated — The bundled collaboration runtime moves up a patch and ships a single lib0 copy instead of two.

KaTeX 0.18.10 — The bundled math renderer moves from 0.18.5.

music-metadata 12 — The bundled audio title and artist reader moves up a major version.

Office previews update docx-preview and @aiden0z/pptx-renderer — Word previews use 0.4.1 and PowerPoint previews use 1.3.0.

Blok.Server takes AngleSharp 1.8.3 and Jint 4.16.4 — The NuGet package's HTML parser and JavaScript runtime move up a patch.

IBlokDocumentConverter gains three methods — Anyone implementing the interface must add FromHtmlAsync, ValidateAsync and ToPlainTextWithReportAsync.

• Callers are unaffected. In practice this touches a test double.
• There are no default implementations, because the only possible defaults would be silently wrong.

A server timeout under 100 ms or an allocation budget under 8 MiB is rejected — Create and AddBlokDocuments throw ArgumentOutOfRangeException at the call.

• Both floors sit below the measured failure points, so no value that worked now fails.
• A host catching InvalidOperationException around construction no longer catches it.

HTML converts into blocks — FromHtmlAsync gives ToHtmlAsync an inverse, so a host importing legacy content needs no parser of its own.

• Covers headings, lists with depth and start, tables with colspan and rowspan, images, details as a toggle, code with its language, and inline marks.
• What it cannot represent is reported as a warning rather than dropped quietly, and the text always survives.

A server can say what a document is without converting it — ValidateAsync answers yes or no, and ToPlainTextWithReportAsync reports what the reader did not recognise.

• A non-document is settled from the JSON in .NET, so no engine is spent on it.
• ToPlainTextAsync is untouched, since '' stays the right answer for a preview caller.

The legacy CMS HTML cleaner ships as @bloklabs/core/preprocess — Standard DOM throughout, in both the string and the in-place form.

Three reachable-only-by-copying surfaces are published — matchEmbedService and buildEmbedUrl from ./tools, USE_BLOK_CONFIG_KEYS from the React adapter, and the four block mutation-type constants.

• A stored link now migrates to exactly what a live paste produces.
• The mutation-type constants had no runtime binding, so importing one type-checked and then resolved to undefined.

A table put every cell's blocks into the first cell when the editor booted detached — Every framework adapter mounts on a detached holder, where the anti-stealing veto went silent.

• Users saw one cell holding every value and the rest empty, on every reload.
• A container now claims a holder that descends from it, not only one that is connected.

A pasted table cell carried an invisible background — Word, Google Docs and legacy CMS HTML stamp the page background onto every td.

• Near-white mapped to the grey preset, and white or transparent persisted into saved data.
• A genuine light grey still maps to the preset.

The view renderer lost children declared only by content[] — A toggle's child rendered as a sibling in HTML, Markdown and plain text alike.

• A content[] entry naming a block the document does not carry is now reported as a dropped construct.
• Markdown import reports a URL it refuses instead of silently losing the image or the link target.

A paragraph holding only an image was deleted as an empty spacer — The legacy importer and the paste pipeline share one emptiness predicate now.

• <p>&nbsp;</p> from Word or Summernote no longer arrives as a blank block.

Reduced motion did not reach navigation scrolling — scrollToBlock, the boot-time deep-link scroll and keyboard block navigation now skip the glide.

A flaky CI attempt no longer strands a release tag — The mirror gate polls until CI is green or the hour is up.

• v1.14.0 never reached the mirror, because the gate exited on the first terminal conclusion.

collaboration:status reports participants, not peers — One entry per person instead of one per connection, and the editor draws no presence stack.

• Each participant carries lastActiveAt, clientIds and the verified userId. clientIds[0] is the old clientId.
• CollaborationPeer is removed. user.name, user.color and blockId carry over unchanged.
• [data-blok-presence-stack], [data-blok-presence-avatar] and [data-blok-presence-overflow] are gone. Draw your own stack from participants.

Offline collaboration requires collaboration.offlineScope — The local copy belongs to a person now, not to the browser.

• Pass a stable, opaque id for the signed-in account, such as offlineScope: currentUser.id.
• Never pass anything that rotates. A ticket or a session id mints a new partition on every refresh.
• collaboration: { doc, offline: true } without a scope rejects the editor's ready promise.

A host onSave no longer replaces the persistence save queue — The two compose, so an endpoint configured under persistence is finally called.

• Vue's v-model:data and Angular's [formControl] synthesize an onSave, so those adapters reached no endpoint at all before.
• api.handlers.set() no longer overwrites the queue, which used to kill autosave for the rest of the session.

19 duplicate icon exports are gone from @bloklabs/core/icons — Every icon is one drawing on a 20-unit canvas with a 1.25 stroke.

• Import the survivor: IconMoveUp to IconArrowUp, IconZoomIn to IconPlus, IconCloseThick to IconCross, IconLinkCopy to IconLink.
• The image-only aliases (IconCropImage, IconCaptionImage, IconImageAlignLeft and the rest) drop the Image suffix.
• Survivors are 20x20 intrinsic where several removed icons were 14x14, so size them in CSS rather than relying on the intrinsic box.

Asset deletion is paired with the uploader that stored the asset — A tool-level uploader's assets are no longer deleted through the editor-level one.

• Add delete(url, ctx) to tools.<image|audio|video|file>.config.uploader, now typed, or its assets are never swept.
• The server shorthand and the file tool's endpoints shorthand are unaffected.

A block's lastEditedBy needs config.user.id — An edit made while config.user is unset now removes the previous author instead of leaving it.

• Under collaboration, config.user.id is published to the room whenever collaboration.user.name is set.
• Pass an opaque per-document token if an internal account key must not travel to peers.
• A name a peer publishes about itself is unauthenticated, so it fills in only where resolveUser had nothing.

Server conversions throw BlokDocumentConversionException — The JavaScript engine's own exception types no longer leave any IBlokDocumentConverter method.

• Catch it and branch on its Reason. OperationCanceledException is unchanged.
• ToPlainTextAsync takes includeHiddenText before the token, so a positional caller must name the token.
• The allocation budget is 512 MiB and configurable, where 64 MiB failed on a 700 KB article.

Readers see the text a media block carries but does not show — blocksToPlainText takes includeHiddenText, off by default.

• An image's alt text, a media url, an embed source and a bookmark description can now reach a search index.
• A quote's legacy caption is read by both readers unconditionally, so extractTexts yields one more string for such a document.
• Re-extract before injecting, or the count check fails.

markdownToBlocks imports a standalone image as an image block — It returned a paragraph carrying a raw <img> string.

• Reference-style links and images resolve against their definitions instead of importing as nothing.
• A legacy toggleList or columns reports action: 'degraded' where it wrongly said 'dropped', so match on action, not on the detail string.

Emoji from the keyboard — Typing : opens a picker inline, ranked by shortcode and then by keyword.

• A closing colon commits an exact shortcode, and the insert is one undo step.
• inlineEmoji: false turns the trigger off. The callout tool's icon picker uses the same component.
• The picker has category icons, a tone switch, search, grid navigation and section jumps.

Collaboration says who is here and when they were last active — participants replaces peers, with a verified identity per person.

• The room broadcasts verified identities, and each peer publishes an activity stamp about once a minute.
• A block's settings menu names whoever actually edited it last.
• Peers without a name draw as anonymous space silhouettes rather than a question mark.

The convert menu groups headings into families — A tab strip replaces one long list, with number strips for the levels.

• Menu items outside the selected family stay hidden until you pick their tab.
• The heading level is exposed on the menu item, so a host building its own menu can read it.

The block menus are laid out as one system — The inline toolbar is a single row, and the block menus are tiled with section separators.

• Inline tools sit in a canonical order, whichever way they were registered.
• The colour picker is split into Text and Background tabs.

A host can watch collaboration activity from the server — Blok.Server hands room activity to an observer you register.

• HTTP edits and resets are journalled, so an edit that cannot be proven fails closed.
• A member's presence is withdrawn when its tab leaves without saying goodbye.

The API reference reads in Russian — Every reference page is translated, not just the landing pages.

Autosave lost edits, wedged, and deleted live assets — Six defects in the save queue and the orphan sweep, each with a regression test written first.

• The sweep deleted assets the live document still referenced, because an upload resolves before the payload naming it arrives.
• A destroyed editor kept saving, deleting and reporting errors into an unmounted host.
• onError never fired while the user kept typing, so a dead endpoint produced 75 rejections and no report.

A reload lost block positions, table text and undo under collaboration — The document is a projection of the shared state now, not a save receipt.

• A prune-only flush is treated as normalisation rather than as an edit, so it no longer races a peer's write.
• A stale-lineage sweep is no longer reported to the host as a server rejection.

The Markdown exporter destroyed what it exported — Conversion mutated the blocks it was handed.

• Currency amounts no longer parse as maths, and a dropped footnote is reported rather than silently lost.

Focus rings appeared on mouse gestures — The keyboard-only gate did not reach, and where it did it stranded keyboard users.

• The popover's focus cursor is drawn only for keyboard navigation.
• A tabbable inside a hidden ancestor is skipped.

A submenu closed while the keyboard was inside it — The pointer grace period now stands down for a submenu the keyboard owns.

The toolbar's left-edge shield killed the plus button — The shield swallowed the click it was meant to protect.

• The inline toolbar anchors to the selected text, keeps itself up for an unchanged selection, and no longer flickers on click.

A stored callout with no body rendered empty — The body paragraph is seeded on load, and the emoji trigger is rewired when read-only is turned off.

Legacy documents read wrong in the view renderer — Containment resolves from a container's content[], and a legacy embed's URL is read.

• A table child that no cell references is indexed rather than dropped.

Mutation testing runs against the whole source tree — A ratchet now fails the build, measured against a baseline built in batches.

• A run is scoped by who imports a file rather than by what the file is named, and a reported mutant can be applied to its source by hand.
• A sweep survives SIGKILL, reaps the workers a timeout leaves behind, and refuses to apply a mutant to a file that has drifted.

blok-sync.v2 drains live — Writes are envelope-only, acknowledged by exact id, and quarantined on rejection.

• Checkpoints publish on a committed-operation threshold, and a failed quarantine no longer loops the drain forever.
• The v1 client is still what a browser negotiates. Do not build on the v2 frames yet.

A release refuses to cut a tag whose workflows lack their secrets — The mirror gate and the delivery check are real checks now, not placeholders.

Icons have a written house spec — src/components/icons/README.md records the canvas, the stroke and the shared frames, pinned by relationship tests.

• The playground gallery previews every icon at 16, 20 and 24 px.

Live collaboration — Real-time multiplayer editing, turned on with collaboration: { doc }.

• Editors on the same doc see each other's edits, carets and avatars, named by collaboration.user.
• offline: true survives a reload by writing document content to browser storage.
• Every tool must support read-only, because a collaboration editor boots read-only.

persistence, server and ticket — The document wiring that used to be yours to write.

• persistence: { load, save } loads on mount and saves as the document changes, against your endpoint.
• Saves are queued, never parallel, and only the newest pending document is sent.
• server fills in the uploader and preview endpoints. ticket names the endpoint minting an access pass.

Documents convert outside the browser — Blok.Server runs the editor's own serializer in-process.

• AddBlokDocuments() registers it, and AddBlokServer already includes it.
• IBlokDocumentConverter gives Markdown, HTML and plain text out, and Markdown in.
• Markdown cannot express every block, so both directions report what changed.

Translate a document without handing a model its JSON — extractTexts and injectTexts move the prose past a model.

• The model never sees the structure, so it cannot drop ids or reorder blocks.
• URLs, file names and code blocks are left out of the list.
• A list whose length does not match the document throws rather than misplacing a translation.

Markdown out of a saved document — blocksToMarkdown is the synchronous, DOM-free twin of markdownToBlocks.

• Headings become #, lists - or 1., and tables GFM pipe grids.
• blocksToMarkdownWithReport also names every construct dropped or emitted lossily.
• Markup written into Markdown comes back as literal text, since Blok has no raw-HTML block.

A heading keeps the anchor its links point at — HeaderData.anchor renders as the heading's id.

• It is captured from a pasted heading's own id, so in-document links survive a paste and a save.
• restoreHeadingAnchors repairs documents already imported without it.
• That pass reports every fragment it refused as no-match or ambiguous, rather than guessing.

An uploader can delete what it stored — delete?(url, ctx) is a third optional method on BlokUploader.

• Blok sweeps the assets this session uploaded and then stopped using.
• With the method absent nothing is ever deleted, which is what happened until now.
• UploaderConfig.headers may now be a function, so a short-lived pass is minted per request.

Change a live document from outside the browser — POST /sync/{doc}/edit and /reset work over HTTP.

• An edit inserts, updates or removes blocks, all-or-nothing, and reaches every open tab.
• A reset reloads the document from your endpoint and tells every tab to pick it up.
• Both require a pass with write: true naming that document.

Pasted HTML ran before anything sanitized it — A pasted <img src=x onerror=…> executed before clean() saw it.

• Clipboard HTML was parsed into an element owned by the live document, which still loads resources.
• Untrusted parses now use a document with no browsing context.
• The URL scheme check moved inside clean(), so a pasted javascript: link is no longer clickable.

A long article could not be converted at all — An article that died on the server's engine now converts in milliseconds.

• Both serializers reallocated the whole accumulated document for every block.
• blocksToHtml also sent every inline field through a sanitizer that parsed twice.
• Measured on the real engine: 600 KB went from failing outright to 7 ms.

A legacy document's nested content read as empty — Plain text, Markdown and HTML all dropped a legacy block's children.

• Documents written before nesting moved to parent and content keep their children inside data.
• Those shapes are now expanded once, in the document model, so every reader sees them.
• One unreadable block is skipped and reported, rather than costing the caller the whole article.

Markdown export lost the fence language and the nesting — Code fences exported unlabelled, and Tab-nested paragraphs exported as code.

• Four leading spaces after a blank line is an indented code block, so that indent survives only inside a list item.
• A container rendered only its direct children, so a list inside a toggle lost every level below the first.
• Lossy conversions now report what changed, instead of reading as "nothing was lost".

The caret did not survive a read-only round trip — Entering read-only remembers where the caret stood, and leaving it puts it back.

• It holds on both the in-place toggle and the save, clear and render path.
• The restore declines when the user focused something else, or when the block is gone.
• A collaboration status blip that changes nothing no longer kills a live caret.

A link to somewhere on the same page opened a new tab — A bare #fragment reopened the whole document instead of moving inside it.

• So did the absolute URL that "Copy link to block" hands out.
• A fragment now scrolls, an identical URL does nothing, and a query-only difference navigates in place.
• Following a link is reading, so the handler no longer unbinds in read-only.

The server runs its own Yjs engine — Nothing it ships carries native code any more.

• YDotNet and the native build matrix are replaced by a managed C# implementation.
• Each wave was verified against a shared Yjs oracle rather than against itself.
• A service account with no home directory now needs no configuration.

blok-sync.v2 is on the wire, and deliberately not spoken yet — The service negotiates it, and the client still offers only v1.

• The operation, acknowledgement and rejection codecs exist on both sides against pinned fixtures.
• An operation id is settled and journalled before anyone can see the write.
• Do not build on the v2 frames until the client negotiates them.

The documentation site was one step from being indexed as its error state — A crawl recorded the homepage's only <h1> as "Application Error".

• A component drew with Math.random() during render, so React 19 discarded the server HTML.
• Docs had also not deployed for three days, blocked by a script demanding impossible release assets.
• A post-deploy smoke test now asserts what the host actually serves.

yarn serve starts the collaboration backend — The dev playground boots the sync service beside it.

• Multiplayer is exercised locally by default.
• Pass --no-server to run the playground alone.

Gates and dependencies — The .NET solution keeps three test layers plus conformance and package smoke tests.

• CI requires 80% line and branch coverage on merged production code.
• It audits NuGet packages, scans for secrets, scans the built image, and analyzes C# with CodeQL.
• Mutation testing runs on the diff alone, carrying surviving mutants between commits.

@bloklabs/server is one C# implementation now, in two forms — The Go service that shipped in 1.11.0 is ASP.NET Core.

• Blok.Server.AspNetCore runs the same handlers inside an app you already have, with no second process.
• npx @bloklabs/server and ghcr.io/jackuait/blok-server still deliver the standalone host.
• Routes, flags and every response wire are unchanged, pinned by a 58-case conformance suite.

Answers pasted from ChatGPT and Gemini keep their structure — A pasted formula used to arrive as roughly 870 layout spans.

• Math is replaced by the <span data-latex> the equation tool already whitelists.
• A code block collapses to one <pre><code>, and its language rides as data-blok-code-language.
• There is deliberately no Claude branch: its share pages sit behind a bot check.

Markdown copied out of an AI answer lost half its structure — A code fence nested under a list item vanished without trace.

• Nested content is emitted as sibling blocks, and later items carry start so markers do not restart at 1.
• Fence languages are normalized through one module that knows the aliases models emit.
• Bold, inline code and strikethrough inside a list item now survive a save.

The Go implementation is gone, and the tag ships the C# one — It was removed only after the dual-target conformance gate passed unwaived.

• The tag workflow packs both NuGet packages and proves them from an isolated feed.
• It smoke-tests the archive and the container image before publishing anything.
• The NuGet credential is minted over OIDC immediately before the push.

Two gates that only CI could see — The dotnet format check was red on main from the day it landed.

• The repository carried no .editorconfig, so the tool fell back to four-space indentation.
• That produced 12689 whitespace complaints, and every step after it never ran.
• The .NET tree now carries its own config, so a laptop and a runner agree.

@bloklabs/presets — Ready-made uploaders, so config.uploader is no longer something every project writes.

• supabaseStorage, presignedStorage, cloudinaryStorage, fetchStorage and indexedDBStorage.
• Zero runtime dependencies: a vendor client is passed in, never imported, so your own auth session applies.
• BlokUploader, UploadContext and UploadedAsset are now exported from @bloklabs/core.

@bloklabs/server — A sidecar handling file uploads and link previews, so you write no backend for either.

• POST /upload, POST /upload-by-url and GET /unfurl, run through npx or the container image.
• Uploaded bytes land in a local directory or any S3-compatible bucket.
• Access modes none, proxy and ticket are enforced by startup interlocks rather than warnings.

Cross-block text selection — Dragging across blocks selects the characters under the pointer, not whole blocks.

• Copy, cut, typing, Enter, paste and the mark engine all split the range per editing host.
• It works in Firefox, which Notion's own implementation does not.
• Escape promotes the text selection to a selection of the same blocks.

Block controls on either side — config.toolbarPosition: 'left' | 'right' moves the plus button and drag handle.

• It is live through toolbar.setPosition(), and the reserved gutter width moves with it.
• Logical tokens throughout, so RTL mirrors for free.
• Before this, the only lever was hiding the controls entirely with hideToolbar.

Dev override seam — Every @bloklabs/core entry consults globalThis.__BLOK_DEV_OVERRIDE__ before its bundled implementation.

• It is a passive, in-realm read: nothing is fetched, evaluated or resolved from a URL.
• The editor root carries data-blok-version, so what is running is inspectable.
• To drop the branch from your bundle, alias the newly exported ./dist/* subpath.

onChange fired late, or not at all — Sustained typing produced zero calls until the user paused.

• Every mutation restarted the 400 ms window, which now opens on the first change and never extends.
• onChange leads the window on the next microtask, and the rest coalesces into one trailing call.
• onSave keeps the trailing edge only, since serializing the document is too expensive to front-run.

Selection beside a nested block — A lasso drawn beside a nested table selected the whole toggle section.

• Selection now resolves which block owns a row through the same rule the toolbar uses.
• A fast drag no longer drops every row above the first throttled mousemove.
• One keystroke inside a nested block no longer runs the pipeline once per ancestor.

Empty-block placeholders displaced the caret — An empty paragraph painted its caret 315 px to the right.

• A placeholder in normal flow consumes real inline advance at the start of the line box.
• Placeholders now paint their text while claiming zero advance.
• Media captions stay in normal flow, since a zero-width box would spill a centred caption sideways.

A bookmark that could not be previewed — It showed an error after the paste, and an ordinary card after a reload.

• The error state never reached saved data.
• A failed preview now degrades to a plain link on both paths.
• Roughly 30% of sites publish no preview data, so this is the ordinary case rather than a fault.

Audio player card — Descenders in the title and artist lines were sliced flat.

• text-overflow: ellipsis forces overflow: hidden, which clips at the padding box.
• At a line height of exactly 1, that box is shorter than the font's content area.
• Both lines now use the line-height token the file-name row already carries.

Release and CI wiring — Nothing here iterates workspaces, so a package missing from a list drops out silently.

• Both new packages are registered across all seven lists, from version lockstep to the publish gate.
• The server's binaries and image ship from a tag-triggered workflow, not from a maintainer's laptop.
• A compiler-API law fingerprints every type @bloklabs/presets hand-copies into its declaration.

Docs — New /presets and /server pages, linked from the navigation and localized in both languages.

• /server leads with the path that runs no service at all, and states its limits on the page.
• A new page documents the dev override seam, its threat model and its opt-out.
• SECURITY.md commits to acknowledging a report within five business days.

Framework adapters — useBlocks takes { within: blockId }, so a container re-renders only for its own subtree.

• Unscoped, a page of N containers turned one keystroke into N re-renders.
• childContentAttributes applies per-child decoration on each child's content wrapper.
• toolbarAnchorRef and ctx.setToolbarAnchor answer getToolbarAnchorElement from inside the component tree.

View — renderLatex and createLatexRenderer are exported from @bloklabs/core/view.

• The KaTeX chunk was already bundled, but hosts were told to add katex themselves.
• Both apply the options Blok trusts for untrusted input, including trust: false.
• createLatexRenderer() awaits the load once and hands back a synchronous renderer.

insertChild({ caret }) — The caret was permanently lost for a portal-rendered child.

• A React, Vue or Angular child returns an empty host and commits its editable a frame later.
• The block was not yet focusable, so the caret helper cleared the selection instead.
• Placement now re-applies once the child's holder produces an input, one-shot.

Adapter parity — The per-child decoration pass was triplicated across the adapters and is now one implementation.

• Three architecture laws pin the new surface.
• The view entry gained an export-to-declaration drift check.

Container tools — Five things a container block used to hand-roll are now declared. static childTools = { allow?, deny? } lets any container state which tools may be its direct children, enforced by core on insert (a disallowed tool is demoted to allow[0], so Enter always produces a block), on a cross-boundary move (refused) and in the toolbox (hidden) — the selective, insert-aware counterpart to ownsChildren, and the generic form of the Table-only restrictedTools. data-blok-keyboard-owner marks a subtree whose keyboard belongs to the tool: block-level and editor-level keydown/input handling stand down inside it, tag-agnostically, replacing per-key stopPropagation handlers. BlockAPI.insertChild gained an options argument with the same vocabulary as the adapters' useBlocks insert (focus, caret, id, tunes, replace), threaded through insertInsideParent.

Inline tools — InlineToolConstructable.hydrate(root) is a declared contract, called by Block after render, after an in-place setData and after onPaste. Whatever a hook writes is marked data-blok-mutation-free, so re-rendering derived markup is not an edit.

View — blocksToHtml and <BlokView> accept inlineRenderers: tag-keyed, post-sanitize, output inserted verbatim — the inline counterpart of renderers. A DOM-free render can plug in katex.renderToString or a mention chip without Blok shipping either.

Block tree — { blocks: [...] } is now a spec node (BlockRunSpec), valid at the root or as a child of a tree node. A migration holding an already-flat saved document can splice it verbatim: ids are kept, only un-parented blocks are re-parented onto the enclosing node, and only those join its content. Passing a pre-flat block as a tree node throws instead of silently dropping its parent/content links.

Inline equations — A KaTeX span's markup is derived from data-latex, and the sanitizer dropped its tags while keeping their text, so E=mc^2 was persisted as E=mc2E=mc^2E=mc2. What was supposed to hide that — re-rendering on load — never ran: EquationInlineTool.hydrate() had zero call sites repo-wide, so equations went inert on every reload, in the editor and not just in the view. The sanitizer rule now rewrites an equation span's content back to its source on both the DOM and the parse5 pipeline, so new saves are clean and a load heals documents that already carry residue. htmlTextContent reads a mark's source, so previews, outline and search stop reading rendered fragments.

onChange arming — The documented "handler presence arms the change pipeline" contract was false: core defaulted onChange to a no-op unconditionally, so the gate could never disarm and all three adapters' careful handler-presence omission was pointless. Hosts were passing dummy handlers to arm a pipeline that was already armed — and an onSave one also forces a full serialization per change batch. The injection is gone, so the contract holds as written.

Published types — types/data-attributes.d.ts was hand-transcribed and had drifted: 17 attributes missing (including nestedBlocks, the container slot every nesting tool's stylesheet targets) and one phantom key the runtime never had. It is now generated from source and any drift fails an architecture test. The React BlokViewProps was also missing classes.

Dependencies — postcss, brace-expansion, fast-uri, ip-address and undici bumped across the root and docs workspaces.

Superscript / subscript — A new inline tool takes the tenth slot in the inline toolbar, bound to ⌘/Ctrl+Period and ⌘/Ctrl+Comma. The two modes are mutually exclusive, so applying one clears the other. Shipped with glyphs drawn into the shared inline-toolbar type system, translations in all 69 locales, and docs.

Toolbox — Slash-menu entries are grouped under labeled sections, so a long tool list is scannable instead of a flat run of items. Each entry declares its own section.

Tool contract — Blocks carry creation provenance (user/load/api/paste/convert/replay/probe), so a container can tell an author's gesture apart from a document load, a refetch or an undo replay. Enter's container-escape became a per-tool declaration instead of a hardcoded list of Blok's own tool names, so a custom container keeps Enter inside itself without an editor-global onEnter hook. insertInsideParent and BlockAPI.insertChild take an optional tool name, making an appended typed child one atomic operation and one undo entry.

Framework adapters — The React, Vue and Angular block spec gained a general statics passthrough (toolbar anchor, ownsChildren, conversionConfig, the new Enter policy), an api handle, child-tree reactivity, per-child decoration, and an onMounted signal backed by a block:childrenMounted event. Handler presence is runtime-settable through api.handlers.set(), so passing onEnter at all no longer permanently decides Enter's semantics.

Editor — A new opt-in captureClicksBelowEditor places the caret in the last block when the host clicks empty space below the editor. Off by default; registered as a config key in the React and Vue adapters too.

Link — The link field sizes itself to its content, capped at the previous fixed width, and its create, error and edit states were polished.

Nesting — setBlockParent no longer lets a container on the block's own ancestor or descendant chain veto a reparent; an enclosing container claiming a holder used to leave model and DOM permanently divergent (Enter inside a callout nested in another container), and a descendant doing the same nested every appended child inside its predecessor. mountChildBlocks now reclaims a holder stranded in any ancestor container, re-mounts it at its model position rather than last, and preserves the caret across the adoption. Depth indentation moved from an inline margin with a hardcoded exemption list to a depth multiplier resolved through --blok-block-indent-step, so a container tool declines the indent with ordinary CSS and no !important.

Block API — Every handed-out BlockAPI is live, so getChildren() can no longer answer [] for a populated container and setParent/insertChild/moveChild can no longer silently no-op. api.blocks.update() prefers a tool's in-place setData when there are no tunes to apply, so it stops composing a replacement block that destroyed the previous one's portal and left the holder permanently empty.

Inline toolbar — destroy() threw and aborted blok.destroy(), leaking listeners in every module torn down after it: hide() emits Closed synchronously, the handler then ran close(), which nulled the popover mid-teardown. The reference is now detached before hiding.

Popover — Control-less HTML items (the new toolbox section headers) are no longer keyboard focus stops, so a role="presentation" header can't steal initial focus, shift every Arrow/Tab, or be pointed at by aria-activedescendant. Sibling active states refresh after an item is activated, and clicking the item that opened a popover now does nothing instead of reopening it.

List — Tab/Shift+Tab moved the model but not the render: both handlers wrote depth into the tool's live data before calling api.blocks.update, whose in-place diff then saw no change, so save() and the DOM silently disagreed.

Events and data — Keydown from a native form control a tool renders is no longer claimed by the editor. The toolbox merge and the save() extraction stop mutating tool-owned objects, so a toolbox entry carrying data no longer throws on a frozen save() result. A load is not an edit: a block arriving without a timestamp is no longer stamped at construction, so a save round-trip equals the document it came from.

Adapters — The portal registries reject a teardown from a superseded instance, so a same-id re-register survives a late destroy; Vue additionally defined one wrapper component per tool *type*, so a re-register patched the superseded instance and rendered stale data — the wrapper is now per block instance. A React element toolbox icon serializes instead of rendering as [object Object], and the imperative handle keeps the controlled baseline in sync so restoring a draft after clear() is no longer swallowed as an echo.

Styles — The icon stroke is scoped to Blok's own icon markup instead of every path in the subtree. The column floor moved to --blok-column-min-width in CSS, and the static-gutter attribute plus the block-padding tokens are now declared.

Build — scripts/build-angular.mjs derived its adapters contract from a hand-copied list that silently drifted whenever a staged module gained an import; it now derives it from src/adapters.ts, and the staging law test walks the same graph so drift fails at test time instead of build time.

Tests — 23 red e2e tests were root-caused rather than weakened: three were real product bugs (fixed above) and four were stale specs asserting behaviour that later commits deliberately changed. A leaked 600ms language-detection debounce in the code-tool unit tests was also cancelled, removing a load-dependent flake.

Embed — A stored generic embed the host hasn't allowed to be framed now renders as a clickable link card instead of the inert "No embed link" state, so the URL stays visible in both read and edit views and can never be silently lost. A new linkPaste.allowedEmbedOrigins hostname/wildcard trust list gives hosts fine-grained control as a middle ground before the all-or-nothing allowGenericEmbed flag. Tampered stored data stays fully inert, and no new iframe paths are introduced.

Editor — Queries for a block's first editable element now skip mutation-free markers such as a list item's bullet span, closing the remaining "marker ghost" sites where Enter could write an item's own HTML into the bullet and the toolbar centred on the marker's box instead of the text. An architecture test now enforces the guard on every contenteditable selector in the codebase.

Font size — config.style.fontSize now carries one entry per text scenario in every text-bearing block (paragraph, headings, quote, callout, code, toggle, list, checklist, table cells, captions, bookmark cards). Each entry writes that block's --blok-*-font-size custom property, so the same knob is reachable through style.tokens, editor.tokens.set() and plain CSS. An unconfigured editor renders byte-identically to before.

API — beginTransaction/endTransaction group operations spanning a pointer gesture into a single undo entry, for cases where the synchronous transact(fn) cannot reach across async boundaries.

Table corner drag — The bottom-right corner now behaves the way Notion documents it: the grid tracks the pointer through live geometry instead of a unit frozen at pointerdown, a Notion-style grip replaces the old 8px dot, hovering it explains the gesture, appended columns are full width, and the whole gesture commits as one undo entry.

Table auto-scroll — Holding the corner at the scroll container's edge or in the viewport's top/bottom band scrolls and grows the table as it goes. Growth follows the pointer — 8px/s for every pixel held past the edge — rather than a fixed clock.

Table selection — Dragging a row or column grip paints the entire dragged range instead of boxing only the focused cell.

Playground — A text-size slider (80%–150%) scales every style.fontSize scenario from its own CSS default.

Table — An inward corner drag stops at the first trailing row or column that holds content instead of deleting typed cells; the handle is anchored to the grid rather than the wrapper, so it no longer drifts inside the table as it grows; a caret click no longer leaves the corner handle and "+" buttons dead until the user clicks outside; clicking inside a merged cell boxes only that cell, and expanding a selection reaches merge origins, not just spans; a stale pointercancel listener no longer accumulates per completed drag.

Styles — Callout emoji and list markers stay aligned with their text as the font size scales, and the bookmark card's padding, line boxes, gaps and favicon scale with the card's own type. fontSize.callout now wins over fontSize.paragraph in the callout body.

Types — The public Blok class exposes its full API surface.

View renderer — @bloklabs/core/view now reaches visual parity with the read-only editor: every core block (paragraph, header, quote, list, checklist, code, callout, toggle, divider, spacer) renders from single-sourced class modules shared with the editor, view.css is generated from those modules, and a soft isolation root plus reproduced block scaffolding keep the output pixel-equal. A class-parity gate and a view↔read-only visual parity gate now run in CI, and the playground gains a side-by-side Blok View comparison panel.

Paste — Google Docs layout tables are now recognized: multi-row two-column tables carrying photos convert into column blocks, and single-column layout tables unwrap into their content instead of arriving as one-cell tables.

Inline toolbar — The convert menu now opens sideways with its trigger marked selected, and the convert row is styled as the card's header.

Callout — A newly picked emoji jumps into the old one's place, and the emoji picker opens instantly without waiting on its dataset to download.

Tools — data-blok-tool is now stamped on code, callout, divider and spacer roots.

Docs — The docs site advertises its markdown mirrors and declares Content-Signal; the published @bloklabs/core/icons subpath is documented; the README is restructured around benefits, facts and a runnable example.

Security — Stored javascript: XSS closed on two sinks: media download hrefs are scheme-gated, and stored embed renders are gated on the provider registry rather than a bare https: check.

Drag & Drop — Drops on the seam between two blocks now resolve instead of dead-ending; the drop indicator no longer promises a nesting the drop would refuse; side-drops are gated on the columns tool actually being registered.

Columns — The drop animation no longer balloons the row while a block lands.

Code — In read-only mode the language label renders as plain text and the language dropdown toggle is hidden; the copy button keeps the same height in its "Copied!" state.

Toolbar — Multiple editors on one page now show one set of block controls instead of stacking duplicates; the slash-search caret is sized to the input, not the block.

Tooltip — A bubble is never parked in the viewport corner when its anchor stops rendering.

List — The checklist checkbox is centred on its text at any font size.

Embed — Provider popups (e.g. "open in app") can escape the iframe sandbox again.

Audio — Cover art uploads are routed to the image pipeline instead of the audio endpoint.

Shortcuts — BACKSLASH/SLASH render as \ and / in shortcut hints.

Dependencies — All 40 open Dependabot alerts remediated at their root causes.

Marks — New range-aware api.marks inline-formatting engine, with the built-in bold/italic/underline/strikethrough tools migrated onto it. Exposes MarkSpec identity/family/transparent semantics for authoring custom inline tools.

View renderer — New synchronous, DOM-free view renderer published at @bloklabs/core/view (defineBlokSchema + a central dispatcher, plus a React BlokView), for rendering stored block content without booting a full editor.

i18n — New runtime editor.i18n.update() API that makes config.i18n live and repaints already-rendered block DOM, wired reactively through all three adapters.

Config — Reactive contract for readOnly, hideToolbar and inlineToolbar: setting them after construction now takes effect live across the React, Vue and Angular adapters (with sanitize-cache invalidation on inlineToolbar).

Readiness — Scoped, reactive editor readiness: whenAllReady({ within, settleOn }), readyState/subscribeReady, and a useBlokReady hook in all three adapters.

Docs — The documentation site is now crawlable (prerendered metadata, sitemap, AI mirrors) and carries Google Analytics coverage across pages.

Playground — Dev settings panel gains a language picker and an RTL toggle.

Marks — Fixed the trailing-whitespace extension eating later content when a mark ended on a boundary.

Styles — Surface background tokens (--blok-bg-light/-secondary/-tertiary) are now a test-enforced public contract; the gutter stays put in plain read-only so readOnly flips no longer shift layout.

Types — MarkSpec is now imported into the main declaration entry so it resolves for consumers.

Docs — Russian pages are headed by their localized H1; @bloklabs/core/view resolves in the docs build and React fixtures.

Release — The Angular README is now staged into the directory npm packs.

i18n — Locale audits completed across Slovak, Sinhala, Sindhi, Russian, Romanian, Portuguese, Pashto, Polish, Punjabi, Norwegian, Dutch, Nepali, Burmese, Malay, Marathi, Mongolian, Malayalam, Macedonian, Latvian, Lithuanian, Lao, Sorani, Korean and Kannada.

Migrated the docs site to React Router framework mode.

Renamed the default branch from master to main.

Completed npm metadata across the package family and hardened the view/reactive-contract law tests.

API — New public editor.tokens getter/setter for runtime --blok-* theme tokens, with replace semantics and pre-ready buffering (like theme/width/placeholder). Wired reactively through all three adapters: React style.tokens, Vue style.tokens, Angular [styleTokens]. --blok-content-max-width is now honored by database centring and toolbar control placement.

Tools — Custom-tool authoring fixes: tools.update(name, { toolbox }) now flips a tool's toolbox entry at runtime (permission-style insert gating no longer requires recreating the editor), including its insertion shortcut; React createReactBlock accepts a viewComponent rendered while the editor is read-only; React toolbox icons may be React elements; commit() echo idempotency is now a documented public contract.

Embed — Google Docs/Sheets/Slides/Forms/Drive embeds render at a user-adjustable pixel height with a bottom resize handle (200–2000px), persisted to data.height. Aspect-ratio media providers (YouTube, Vimeo, …) are unchanged.

CDN bundles — dist/blok.iife.js and dist/blok.umd.js shipped zero generated Tailwind utilities since the v3→v4 migration, so every unpkg/jsDelivr consumer loaded an unstyled editor. Both configs now run the Tailwind plugin (+34KB gzip each), guarded by a dist-level assertion.

Adapters — Five root causes from a downstream audit: a stale controlled-data echo no longer clobbers the caret (bounded echo window instead of last-payload-only dedup); equalsOutputData compares block ids only when both sides carry one; React inline tools accept a titleKey for localization; the zero-specificity gutter default is a test-enforced public contract.

Dependencies — Seven phantom dependencies (bare imports resolving only via hoisting, including @testing-library/jest-dom used by the global unit setup) are now declared, with a law test preventing new ones.

i18n — Review passes completing Armenian, Croatian, Dhivehi, Filipino, Georgian, Gujarati, Hebrew, Hungarian, Indonesian, Japanese, Kannada and Khmer, plus tool interpolation variable forwarding.

Upgraded to Node 26, Angular 22 and TypeScript 6, then root-caused six defects the upgrade shipped green — most importantly the entire unit-angular vitest project loading zero tests (a fake green), and the docs test suite missing the Node 26 webstorage guard.

Local E2E suite runtime cut from ~47.5 min to ~10 min (parallel/skip-when-fresh build:test, shared page per worker), plus broad E2E stabilization.

Fixed ESLint cache poisoning that replayed stale errors in CI lint runs.

Media — Playback speed and loop preferences now persist across audio and video blocks. They are stored in localStorage under shared per-media-type keys (blok:audio:rate/loop, blok:video:rate/loop), joining the existing shared volume and per-source position keys, and are restored when a player attaches — without dirtying block data.

Quote — Saving a quote block no longer strips href/target/rel from links (leaving dead anchors in stored content) or unwraps bold/italic marks. Quote now uses the same inline-text sanitize rules as paragraph and header, so links, formatting, and color styles survive save and conversion.

Audio — OneDrive share links from SPO-migrated accounts (the new /u/c/<cid> form) can't be resolved anonymously and produced a silently dead player; they now surface a clear "needs an uploader backend" error instead.

Toolbar — The plus button and drag handle no longer stay stuck at the wrong offset after the slash-command popover opens or closes; the toolbar repositions on toolbox open/close instead of relying on a resize side effect.

Toolbox — Opening the toolbox silenced the current block's mutation watching and never re-armed it, leaving the block permanently deaf to later content changes until re-render. Watching is now re-armed on both close paths, and the toolbar follows any inner-geometry change that doesn't resize the block holder.

CI — The build artifact now ships the extracted packages/*/dist adapter bundles alongside dist/, fixing downstream unit and E2E jobs; yarn.lock was synced to the ^1.1.1 core peer range.

Docs — README and the docs site updated for the @bloklabs/* package family; the rename notice was subsequently dropped from the README.

Audio — Share links from seven more services — Dropbox, OneDrive, GitHub, GitLab, Hugging Face, Google Cloud Storage, and Internet Archive — are recognized and rewritten to their direct-content form, so they play in the browser with no backend. Google Drive share links (hotlink-blocked server-side) are normalized and routed through the consumer's uploadByUrl backend, with a Drive-specific error message when none is configured. The error state gets a styled callout with a retry button.

Read-only — readOnly now accepts an object form: { hideControls: true } enables read-only mode and suppresses the toolbar, block settings, and inline toolbar. Exposed via isControlsHidden, normalized across the React, Vue, and Angular adapters, and ReadOnlyModeConfig is exported from the types root.

Image — compress: { format: 'avif' } now produces real AVIF via WebCodecs when the canvas encoder cannot, and a new fallbackFormat option (e.g. 'webp') covers browsers with no AV1 encoder instead of silently uploading the original bytes.

Audio — Audio inserted by URL is now enriched like uploads: waveform, title/artist metadata, and cover art, failing soft to a plain scrubber when the host blocks the CORS fetch.

Table — Undo inside a table no longer duplicates cell blocks into invisible ghosts that reappear under the table after save; blocks placed at the top of a cell no longer drift to the bottom or become orphans on save. The Saver gains save-boundary guards for cell membership and cell block order (throw in dev/test, repair the emitted output in production).

Tooltip — The tooltip bubble is click-transparent, so it never swallows clicks on controls it covers (e.g. color-picker swatches under a bottom-row tooltip).

Popover — Nested popovers no longer collapse to their padding in WebKit; the marker color picker rendered as a 12px sliver in Safari.

Styles — Body-mounted UI (link hover card, notifier toasts, drag previews) now carries the scope attribute, so its styles survive in consumer apps; a new architecture test enforces the invariant for every document.body mount.

Angular — The ng-packagr build stages the readonly-config module, fixing a CI-only TS2307; an architecture test now walks the adapter's import graph to catch unstaged modules.

Playground — Gallery empty states run the real tool per state (with per-state tool config) instead of static mockups, including a live Google Drive error demo.

Tests — Adversarial table undo probes (merge undo, insert undo/redo), tooltip click-transparency lifecycle guards, and an exhaustive swatch hit-test sweep.

Header — Toggle headings are now offered at all six levels, staying in sync 1:1 with regular headings.

Migration — The legacy Editor.js grammar is now authored as ESM so consumer dev servers can load blok's source graph without a build step.

Columns — Blocks inserted via the plus button no longer save at the bottom of the column; saved order now matches the on-screen (WYSIWYG) order.

Styles — Injected utilities are scoped so a host application's CSS reset can't flatten the editor.

Migration — Single-source LEGACY_GRAMMAR shared by both the runtime and the codemod; the codemod's source rewrite is now AST-guided (via the consumer's @babel/parser) to avoid mangling comments, strings, and unrelated identifiers.

CI — Root-caused CI failures: scoped-utility drift on body-mounted UI, lint, and test flake fixes (webkit paste timing, six-level toggle-heading counts).

Spacer — New adjustable-height spacer block. Drag either edge to resize (dual-edge grips), with a text-block-height floor, snap-to-sibling and snap-to-column alignment guidelines, an on-edge capsule resize pill, and accent hover cues. Fully invisible in read-only/published renders.

Image — Uploads are now automatically compressed and re-encoded (compress, on by default), with opt-in smaller output formats. In-cell images gain a resize floor and fluid chrome via container queries.

Toolbar — Cmd/Ctrl+Slash opens the block menu in read-only mode.

Table — Large batch of Notion-parity fixes: paste-header handling, the cell color picker, the cell menu, arrow-key navigation between cells, and column width reset. The cell box now follows the caret (instead of the pointer) and the resize handle no longer forces overflow. Focus stays inside a cell when its content is deleted, the caret stays put after clearing a multi-cell selection, multi-line cell selections merge into one rounded shape, drag-selecting several lines within a single cell works, and list items scale to the cell font instead of outsizing sibling paragraphs.

Columns — Stranded resize separators left behind by removing a column no longer render as a phantom column.

Core — Never Tab-indent a block into a tool-owned container.

Toolbox — Keep plus-button blocks on a table out of its cells, and anchor fuzzy search at word boundaries.

Selection — Stop hijacking intra-line text drags inside table cells.

Embed — Validate stored URLs at render time (stored-XSS guard).

List — Keep bullet markers non-editable so Enter never ghosts an item.

Toolbar — Read-only drag-handle refinements: announce it as a menu button, show a pointer cursor, and drop the ⌘/ and "Drag to move" hint lines; no read-only handle appears beside blocks that paint nothing.

Tunes — Hide the copy-link shortcut hint in read-only mode.

Styles — Right contentAlign no longer collapses into centering, and preflight resets are scoped to @layer base so Blok's own utilities win.

React — Guard against stale dist exports and a StrictMode readiness race.

Vue — New first-class @jackuait/blok/vue adapter: BlokEditor component, useBlok, and provideBlok, plus createVueBlock/useBlocks for authoring custom blocks and driving the block tree from Vue. Custom Vue blocks support read-only in-place toggling.

Angular — New first-class @jackuait/blok/angular adapter shipped as an Angular Package Format build (ng-packagr): the editor component/directive, a block portal registry, the BLOK_BLOCK_CONTEXT render-context token, createAngularBlock authoring, and the reactive injectBlocks block-tree API.

React — New useBlocks hook exported from @jackuait/blok/react: a reactive block-tree API with reads, insert (position + append-to-parent, explicit id, tunes, replace), move (before/after/toIndex), nest/unnest/remove/transact, insertMany, atomic insertTree for nested subtrees, and additive insertMarkdown. Block-creation semantics are hardened across hierarchy edges with compile-time drift guards against the core API.

Adapters — Closed React/Vue/Angular parity gaps across component paths and escape hatches; shared one blocks-api core so Vue's useBlocks reaches React parity, and extracted shared fillDefaults/PropSchema helpers. Custom-block authoring is now first-class on the public API surface.

Accessibility — Five-wave overhaul adapting shadcn/ui interaction patterns to Blok's UI primitives: dismissal-layer/popover teardown/scroll-lock/announcer foundations, an anchored-positioning engine and shared modal Dialog, keyboard reachability for toolbars/menus/radios/rename, and assistive-tech feedback parity across selection, drag, menus, and arrival.

Link — Clickable links with a hover card in both edit and read-only modes (with enter/leave animation), an edit mode featuring a title field and remove-link action, refined hover-card chrome, blocking of unsafe-scheme navigation, and a consistent same-page/anchor-link rule that opens such links in the same window across all link-creation paths.

Blocks — Structural parentId nesting: any block can now be nested inside any list (flat per-block indent), with list keyboard nesting and drag/serialization migrated onto the structural block tree.

Keyboard — Cmd+Left/Cmd+Right navigate between blocks at block edges; Backspace at the start of a nested block removes one indent level; mixed-list Tab indents both kinds; and numerous Notion-parity Tab/arrow/Delete/Backspace fixes.

Paste — Paste-without-formatting (Cmd/Ctrl+Shift+V); recovery of buildin/Notion toggles and soft breaks from lossy GFM HTML fallback.

Inline — Link-markdown auto-format and a link-paste menu; shortcut-triggered Link/Equation/Marker now open a standalone menu positioned right under the selection.

Popover — Custom cross-platform scrollbar that hides the classic OS bar while keeping a stable gutter; reel-like edge distortion replacing the scroll haze.

Convert — Shared buildConvertMenuEntries with titleKey resolution, used by both block settings and the inline "Turn into" menu (which now lists the full text family), guarded by parity E2E.

Image — Configurable auto-retry on image load failure (default 5).

CRDT/Yjs — Undo/redo no longer yanks the caret to the top of the document; the caret restores to the correct position, split() inherits full tool data (correct heading undo caret), redo moves the caret to the new block on an Enter split, and five further Yjs sync gaps in tools and modules were closed.

List — Closed dozens of Notion-parity divergences across convert, keyboard, drag, selection, and copy/paste; source ordered lists renumber when an item is dragged away; bullet glyphs refresh on depth change.

Text/Header — Fixed 30+ Notion-parity bugs by root cause (slash+space, duplicate pulse, indent toolbar, caret offset preservation on turn-into, and more).

Table — Preserve merged cells and lists when pasting external tables, and keep list markup when copying cells out to external apps.

Paste — Preserve lists and quote-ness in pasted blockquotes; pasted links use the default link color; the link menu shows on non-empty blocks without erasing content; closed remaining sanitizer/merge data-loss gaps found by an audit.

Blocks — Re-parent a merged block's children onto the survivor instead of orphaning them; release toggle children as siblings when turning a toggle into text; fire the tool moved() hook on setBlockParent; never write split text into a mutation-free decoration.

Columns — Match Notion's inter-column gutter spacing; restore DOM order when undoing column creation.

Drag — List-item drop line tucks under the text with a marker lead-in; depth changes apply on same-slot drops; non-list blocks stop previewing nested drops they can't reach.

Selection — Fake highlight matches the native selection color and stays visible while a menu input is focused; Cmd+A container-scoped staging.

Marker — Reset <mark> background so colored text never shows the browser's yellow highlight.

Toggle — Arrow container stays a constant 28px square and pins to the first line for multi-line toggle/heading.

Styles — Reserve a scrollbar gutter on all scrollable components and keep it in nested inline-toolbar menus; auto-hide scrollbars system-style while keeping the gutter.

Paste — Mechanically enforce the paste attribute law and the paste stamp law via architecture tests.

Tests — Repaired all CI-matrix E2E shards; added regression coverage across list keyboard shortcuts, columns undo order, popover scrollbar spec, and adapter integration/e2e.

Lint — Resolved all 69 root ESLint problems at the root cause.

React — A blessed <BlokEditor> component is now the recommended way to embed Blok in React. It forwards a typed ref to the live editor instance, takes an uncontrolled data seed, and reactively syncs readOnly, autofocus, theme, and width props without recreating the editor. Its onReady callback fires after the ref commits, so consumers can safely call ref.current from inside it. The lower-level useBlok hook plus BlokContent remain available as an escape hatch.

React — useBlok now reactively syncs theme and width prop changes to the editor instance, mirroring the existing readOnly/autofocus pattern.

Docs — The demo wrapper now dogfoods BlokEditor, and the README React section documents the recommended BlokEditor path, the uncontrolled data contract, reactive props, and the useBlok + BlokContent escape hatch.

Tests — Added e2e coverage for save-via-ref and live prop toggles, a published-vs-source type-drift guard, and data-blok-testid-based locators.

Paste — Content copied from buildin.ai now imports as native Blok blocks at full fidelity. buildin's clipboard carries a lossless text/next-space-blocks JSON payload beside a lossy Markdown/HTML twin; Blok previously fell back to the twin, where tables collapsed to literal |pipes|, media degraded to links, and callouts, toggles, columns, to-dos, and code language flattened away. A new handler decodes the JSON directly, reconstructing the same native blocks as a Blok→Blok paste — paragraphs, to-dos, H1–H4, tables (grid + parented cells), bulleted/numbered lists, toggles, dividers, quotes, callouts (emoji + colour), code (with language), equations, toggle-headings, column lists, and image/video/audio/file/embed-bookmark media. (Inline marks — bold/italic/link/colour — are a documented follow-up.)

Paste — Callout body and colour now survive import from both Notion and buildin.ai. Blok's callout stores its body in child blocks, so the inline title/body text the parsers emitted as data.text was silently discarded — the callout is now emitted (colours only) plus a child paragraph carrying its text. Out-of-palette callout colours (e.g. buildin's British grey, or any name outside Blok's 9-colour preset) previously produced an undefined CSS variable that dropped both the background and the border; colours now normalize through Blok's preset palette (grey→gray; unknown names clamp to null).

Paste — Rich clipboards (Notion and similar) ship both a faithful HTML payload and a lossy Markdown twin. Routing now prefers the HTML handler, so pasted images, links, and structure the Markdown twin drops are preserved.

Paste — Notion content keeps its document order: nested children no longer render above their parents (only table cells stay children-first, since the table tool resolves cell ids on insert). Internal references that previously vanished — sub-pages, linked databases / collection views, and inline page mentions — now paste as Notion bookmarks/links instead of being dropped or leaking the raw "‣" glyph, and uploaded media whose binary isn't on the clipboard becomes a Notion-link bookmark carrying the filename rather than a bare filename paragraph.

Paste — Pasted external Notion audio now shows its title (the player reads data.title, which was left blank), and a malformed inline date annotation no longer leaks the raw "‣" placeholder glyph.

Tests — Added regression coverage for HTML-over-Markdown routing, document-order preservation, internal-reference rescue, pasted audio titles, and date-glyph handling.

Paste — Content copied from Notion now migrates as native blocks with full state preserved. When Notion's lossless clipboard JSON is present it is used directly (the high-fidelity path), with an HTML fallback for sources that only expose markup. Inline equations and page mentions are mapped to their Blok equivalents.

Audio — Custom cover art. A cover picker (file upload or image URL) opens from an editable overlay button on the player; covers can be set, replaced, or removed (via a "Remove cover" block setting), with an animated picker open, a sliding Upload/Link tab transition, a themed surface that matches the player, and i18n across all locales. Audio blocks with no cover now show an inertial spinning-vinyl turntable placeholder instead of an empty panel.

Audio — Repaired the transport controls and the video-style playback-speed menu, which now stays open after picking a preset. The volume bar fill is fixed so a muted track reads differently from a full one, and the playing waveform pulses smoothly without gouging its dots. The caption toggle stays on the compositor, and the cover picker no longer jumps height on tab swap, gets an explicit width so the URL field isn't cramped, and revokes leaked cover blobs on a destroy race.

Table — Pinned the top toolbar anchor flush to the table edge.

Tests — Added unit and e2e coverage for custom cover set/remove and for real Notion page-mention arity, and cleared the lint/type violations the cover-art work introduced.

Width — New public width API on the editor instance: instance.width.get(), set('full' | 'narrow'), and toggle() switch the content layout between 'narrow' (the default, constrained to --max-width-content) and 'full' (the content max-width is removed so it fills its container). It mirrors the theme API, including buffering a set() call made before the editor is ready and replaying it once the editor is initialized.

Types — Declare the history API on the exported Blok instance type. history (clear(), undo()/redo(), canUndo()/canRedo()) was already available at runtime; consumers no longer need to cast the instance to reach it.

Audio — New native Audio block tool. Now-playing card with cover art (lazy music-metadata extraction), a waveform canvas with click/drag seek, transport controls (play/pause, volume, playback speed, loop, keyboard shortcuts, persisted preferences), file and URL upload, paste handling routed away from the File block, read-only support, and i18n across all locales. The player card is a full-bleed redesign — a tall cover panel (music-note placeholder when there is no art), a hero waveform scrubber with rounded bars, a slim transport bar, and motion polish.

Media — Image, video, and audio blocks now accept any file of their media family (image/*, video/*, audio/*) by default. Restrict the accepted types through the existing types config, which now accepts both exact MIME types (image/png) and family wildcards (image/*).

Types — Export File, Audio, and Video (and their data/config/uploader types) and add the file/audio/video keys to defaultBlockTools from the @jackuait/blok/tools types entry. The runtime already exported these tools; consumers no longer need a local ambient type shim to import them.

Playground — Audio block states in the block-states gallery (real ID3-tagged track and a "No cover art" state) plus an e2e harness for insert/upload/play/seek.

Video — New native Video block with a custom Airbnb-style player, brought to YouTube parity: full keyboard control (j/l/k, 0–9, Home/End, frame-step, volume, speed), a scrubber with buffered range, hover frame-preview tooltip and mini progress bar, an in-player gear menu (Notion-style playback speed with glide, loop, ambient-glow intensity), and view modes — picture-in-picture, a FLIP-morphed theater/cinema mode, and a fade-in ambient glow. Player polish includes click-to-toggle play/pause, a centre play/pause burst, press-and-hold for 2× playback, arrow-key ±5s seek with side indicators, idle auto-hide, buffer spinner, time-remaining toggle, right-click menu, stats overlay and persisted preferences.

Video — Custom fullscreen surface with a top caption bar, a "Hide controls" tune for a control-free player, and GIF-style autoplay/loop tunes.

Image — Auto-convert dropped, pasted and remote-URL GIFs into a looping Video block via WebCodecs + webm-muxer, gated by the convertGifToVideo config (default on); the original GIF is kept on CORS failure, with a "Converting…" label shown during conversion.

Media — 30MB default upload limit with per-type maxSize configuration and human-readable too-large errors.

Paste — URL paste always prompts now; the previous auto-embed behaviour has been removed. Breaking: consumers relying on silent auto-embed must opt in through the paste menu.

Video — Reserve the aspect ratio before metadata loads to prevent squeeze-on-load, centre and letterbox the fullscreen player, strip editor chrome in fullscreen, and hide the bottom mini progress bar while fullscreen.

Video — Exit theater mode reliably on Escape via a capture-phase listener with a smooth deferred dismiss, and drive the scrubber fill with requestAnimationFrame for smooth playback tracking.

Build — Move webm-muxer to devDependencies so it is bundled rather than treated as an external runtime dependency.

README — Replace the logo with the optimized noodle mascot.

Playground — Use real self-hosted videos in the block-states gallery.

File — New File block tool. Tabbed empty state with upload (validation, progress bar, cancel), URL and drag-and-drop; per-type icon and tint; editable filename; consumer upload endpoints and download card. Rich preview modal dispatched by kind: PDF (top-layer modal with open-in-new-tab), Office (docx/xlsx/pptx via lazy renderers, xlsx parsed through JSZip), and text/code/markdown — including advanced markdown (math, footnotes, references, alerts, anchors, safe block-level raw HTML) with an animated Rendered ⇄ Raw toggle. Read-only support, i18n in every locale, and Storybook stories.

Embed — Generic embed: frame arbitrary URLs through a gated resolver, offered in the paste menu behind the linkPaste.allowGenericEmbed flag with an api.config accessor. Replace the source via an empty-state URL bar and an overlay more-menu item.

Migration — Complete Editor.js block-type coverage plus a drop-in UMD build; adapt legacy Editor.js inline tools and linkTool data.

Playground — Block-states selector as a fixed left side menu; real docx/xlsx/pptx, code and text samples for the File block; richer quarterly-budget sheet; File block wired into the editor demo.

Table — Resolve merged-cell coordinate bugs; preserve merges on load; split overlapped merges on paste so no destination data is dropped; keep empty cells editable on the read-only→edit toggle; harden input, clipboard and move-guard handling.

File — Unbreak pptx preview; vertically center the preview modal; stop wrong-colour strips and toggle flicker during preview transitions; block javascript: URLs in download hrefs.

Build — Make the published install self-contained (ship src, keep markdown and nanoid as runtime deps) so bundlephobia can build; green the self-contained-install and css-token audits.

Refactor — Extract table visual-subsystem orchestration into TableSubsystems; split BlockOperations into focused worker classes; share the media uploader empty state across the image and file tools.

Code — Cover every Prism token in both the light and dark themes.

Lint — Resolve all lint errors by root cause and mute advisory-only rules.