• fix(core): restore a group's 'no-drop-target' lock through fromJSON by @mathuo in https://github.com/dockview/dockview/pull/1700
• feat(core): serialize a single group and add it to a live layout by @mathuo in https://github.com/dockview/dockview/pull/1699
• feat(core): groupIdGenerator option by @mathuo in https://github.com/dockview/dockview/pull/1701
• feat(core): merge form of addGroupFromJSON, addPanelFromJSON, drop index by @mathuo in https://github.com/dockview/dockview/pull/1703
• docs: weekly documentation sync (2026-10-16 to 2026-10-23) by @mathuo in https://github.com/dockview/dockview/pull/1707
• fix(dockview-core): cancel pending resize-end callback on dispose by @mayuriphad in https://github.com/dockview/dockview/pull/1709

• @mayuriphad made their first contribution in https://github.com/dockview/dockview/pull/1709

Full Changelog: https://github.com/dockview/dockview/compare/v8.6.1...v8.6.2

• [@mantine/schedule] Fix time slot labels showing wrong time on daylight saving time days in DayView, WeekView, ResourcesDayView, ResourcesWeekView (#9320)
• [@mantine/hooks] use-mask: Fix generatePattern output being rejected by browsers for masks with # token (#9326)
• [@mantine/core] NavLink: Add aria-expanded to links with children (#9325)
• [@mantine/core] Menu: Add aria-disabled to items and Menubar targets with data-disabled (#9323)
• [@mantine/core] Preserve zero alpha when converting hsla colors (#9321)
• [@mantine/schedule] DayView, WeekView: Fix events and current time indicator being positioned at wrong time on daylight saving time days (#9317)
• [@mantine/schedule] DayView: Fix multi-day events starting at midnigh… (#9315)
• [@mantine/core] ScrollArea: Stop thumb animation loop on cleanup (#9314)
• [@mantine/hooks] use-clipboard: Reset copied state on error (#9310)
• [@mantine/hooks] use-hover: Fix listeners not being removed when React detaches the ref (#9309)
• [@mantine/core] TagsInput: Fix readOnly not preventing value changes on paste (#9308)
• [@mantine/core] Tree: Fix ArrowLeft and ArrowRight not being mirrored in RTL (#9307)
• [@mantine/core] SegmentedControl: Fix readOnly prop description (#9306)
• [@mantine/core] Checkbox: Forward readOnly attribute to the input (#9305)
• [@mantine/core] AppShell: Keep the context value stable when the shell re-renders after mounting (#9304)
• [@mantine/core] Menu: Fix ArrowLeft and ArrowRight not being mirrored in RTL submenus (#9302)
• [@mantine/core] Menu: Fix focus not returning to the submenu target on ArrowLeft (#9301)
• [@mantine/hooks] use-local-storage: Fix stale value after key change (#9298)
• [@mantine/charts] Support Recharts legend position (#9297)
• [@mantine/hooks] use-fetch: Fix stale error and loading state when a request is replaced or aborted (#9296)
• [@mantine/core] SegmentedControl: Fix indicator position not being changed when data array is reordered

• #891 by @bobsingor – doc.changes takes the attachment ops under doc.attachments.modify. New operations: doc.attachments.list, doc.attachments.download and doc.annotations.readFile.

• #885 by @bobsingor – The contract gains doc.outline.get, and doc.changes takes the outline ops under the doc.outline.modify capability. The outline's models are named once in the OpenAPI document.

• #890 by @bobsingor – doc.changes takes the page ops under doc.pages.assemble, with a PDF to insert as a multipart part. The operations doc.pages.reorder, doc.pages.rotate, doc.pages.delete, doc.pages.insert and doc.pages.insertBlank are removed: page edits are changes.

• #883 by @bobsingor – The doc.pages.extract operation describes its flatten options and their permissions.

• #891 by @bobsingor – On the cloud engine, doc.attachments.create() and delete() are changes that can be undone, sent through POST …/changes, and download() returns the bytes. Another session follows attachments.restored.

• #885 by @bobsingor – doc.outline on the cloud engine: the outline is read from the shared URL while the layer inherits it, from the layer's otherwise, and its edits are undoable changes.

• #890 by @bobsingor – On the cloud engine, doc.pages.rotate(), reorder(), delete(), insert() and insertBlank() are changes that can be undone, sent through POST …/changes.

• #883 by @bobsingor – pages.extract(pages, options) sends its options to the server, so a cloud document makes flattened copies too: { flatten: { usage: 'print' } } returns the pages as they print.

• #883 by @bobsingor – page.render.image() makes print pictures (usage: 'print', viewport: { kind: 'dpi', dpi: 150 | 300 }), fetched from the print family's path at its tier (render/print/… or render/print-high/…). A session whose rights the client knows is refused before the request without doc.print, or doc.print.high at 300 DPI.

• #891 by @bobsingor – Another session's outline edits, and its undos of annotation deletes, move this session's cached pins, so it never reads the old outline or annotations from a cached URL. Every remote event kind is named where they are absorbed, so a new one can't be forgotten.

• #891 by @bobsingor – A new doc.attachments resource with list and download, and doc.annotations.readFile for a file attachment annotation's file. doc.changes ops include attachments.create and attachments.delete, each undone by its opId.

• #885 by @bobsingor – doc.outline.get() reads a document's outline, and changes take the outline ops.

• #890 by @bobsingor – doc.pages no longer has reorder, rotate, delete, insert and insertBlank: page edits go through doc.changes, whose ops now include pages.rotate, pages.reorder, pages.delete, pages.insertBlank and pages.insert, and each can be undone by its opId.

• #891 by @bobsingor – Attachments are changes: POST …/changes takes attachments.create (its file as a resource:<key> part) and attachments.delete under doc.attachments.modify, and undoes them by opId. The routes POST …/attachments and DELETE …/attachments/{fileKey} are removed, and file downloads no longer carry X-EmbedPDF-File-Name and X-EmbedPDF-File-Type: the listing has both. New current reads: GET …/attachments, GET …/attachment-files/{fileKey}/data and an annotation's GET …/items/{annotKey}/resources/file.

• #885 by @bobsingor – The document's outline: GET /v1/docs/:docId/outline@{token} (shared and cacheable while a layer inherits the outline and the layout) and GET /v1/docs/:docId/layers/:layerName/outline, with outline edits through POST …/changes. Layers and published versions carry an outline version (migration 035_outline_version), outline ops move it, and its plane decides when a layer reads the shared outline. A token that may change the outline (doc.outline.modify) is handed object numbers for new items, as one that may create annotations is.

• #890 by @bobsingor – Page edits are changes: POST …/changes takes pages.rotate, pages.reorder, pages.delete, pages.insertBlank and pages.insert (its PDF as a resource:<key> part) under doc.pages.assemble, and undoes them by opId. An undo of a delete brings the same pages back with fresh page pins, so no picture cached before they went is served for them. The routes POST …/pages/reorder, /pages/rotate, /pages/delete, /pages/insert and /pages/insert-blank are removed.

• #883 by @bobsingor – POST /v1/docs/:docId/layers/:layerName/pages/extract takes flatten ({ usage?: 'display' | 'print' }), includeAnnotations and includeFormFields, and returns the pages as they draw for that usage. A flattened copy passes on doc.download or doc.download.flattened (a signed document refuses the latter), and paints only what the token may read; the include options are refused without flatten.

• #883 by @bobsingor – Serve the print pictures at both tiers: each picture family printed at 150 DPI under render/print/ (needs doc.print) and at 300 DPI under render/print-high/ (needs doc.print.high), on top of the family's own rights. A print picture's token is its pins and its format; the server sizes it from the DPI and the paper. Print pictures are cached at their versioned URLs but never stored or refused by the render lattice.

• #883 by @bobsingor – viewable(annotation, engaged) takes the annotation instead of its flags, and follows ISO 32000-2 12.5.3 for invisible: the flag hides only an annotation of a type that isn't standard (an unsupported annotation PDFium doesn't know, other than Projection). On a standard annotation it means nothing. The engine's renderer and flatten follow the same rule, so the viewer no longer paints an unknown annotation that printing and flattening leave out.

• #895 by @bobsingor – New textBoxOf(model, id, view?): one free text's box whether its text is live or saved and idle. textBoxes still lists only the live ones, the boxes a viewer draws as elements; a saved, idle box shows its engine picture there.

• #891 by @bobsingor – @embedpdf/core/testing gains gate(engine), an engine whose documents hold every change until a test releases or refuses it, so a plugin's tests can see what the reads show while a change is on its way. A predicted attachments.restore op lets a view draw an undone attachment removal before the engine answers.

• #885 by @bobsingor – PredictedOp gains outline.restore: the items as they were, at their place, which is how an undo of an outline change is drawn before the engine answers.

• #883 by @bobsingor – The documents capability prints. print(id?, { pages, includeAnnotations, onProgress }) makes the pages as they print (layers, annotations and form fields by their print settings) and hands them to the host's print dialog. preparePrint(id?, options) does that ahead and resolves { quality, pageCount, needsTap, print(), dispose() }, so a dialog prepares when the user presses Print and then prints; its print() prepares again when the document changed since. needsTap is the printer's: true where printing works only from a tap (Safari), so a dialog asks for another tap once the print is ready. getPrintQuality(id?) says how it prints: { kind: 'pdf' } — a copy of the pages as they print (pages.extract with flatten: { usage: 'print' }), sharp text and lines — with doc.print.high, a right to keep the copy (doc.download or doc.download.flattened) and a printer that prints PDFs; else pictures, { kind: 'images', dpi: 300 } with doc.print.high or 150 DPI with doc.print only; null when it can't. When the printer turns the PDF down, preparing or printing, the same pages print as 300 DPI pictures. Form fields print whenever the user may read the form, with or without the annotations. Printing waits for changes still on their way, as a download does. The host hands the kernel its printer, createKernel({ printer }) (HostPrinter, with stagePdf when it prints PDFs and needsTap when it prints only from a tap), and canPrint() is doc.print and a printer. A plugin runs the document's own around the print dialog with ctx.aroundPrint(wrap); the test context's print(run) runs those wraps.

• #890 by @bobsingor – The page list follows pages.restored: pages an undo brings back show again.

• #885 by @bobsingor – treeKeyAction(rows, focused, key, options) is the keyboard of a tree view, as the ARIA tree pattern has it: the arrows, Home and End, *, Enter, and F2 and Delete when the tree is editable. Pure: a view hands in its rows and the key, and does what comes back.

• #891 by @bobsingor – Attachments are change ops: attachments.create (the file's name, type and description, its bytes as the file resource) and attachments.delete, each recorded with its reverse, so doc.apply({ undoOf }) undoes and redoes them. An undo of a delete brings the same file back, with its bytes, description and dates, and publishes attachments.restored. attachmentVerbs() makes doc.attachments.create() and delete() one-op changes. doc.attachments.download() returns the bytes; the name and type are what the listing says, as for an annotation's downloadResource(ref, 'file'). ATTACHMENT_LIMITS.decodedBytes names the local engine's decode limit, and AttachmentWireComponents the attachment models. wirePaths no longer lists the attachment write routes; wireTemplates gains the current attachment reads.

• #885 by @bobsingor – Read and edit the document's outline (its bookmarks) with doc.outline: get() lists every item depth first with its parent, its target in page space (read the way a link's is), its /A action tree, its colour, its style and whether it opens; create, update, move and delete are change ops (outline.create, outline.update, outline.move, outline.delete) that apply through doc.apply, undo by reference, and publish outline.created, outline.updated, outline.moved, outline.deleted and outline.restored events. Items are named by object number and placed by neighbour (OutlinePosition); a delete takes the items under an item with it, and its undo brings the same items back. Writing needs the new doc.outline.modify capability (granted by the PDF's modify or assemble right, and protected by certifying signatures).

  outlineItemOfDraft, outlineItemAfter and outlineItemWithChildren work out what an outline write leaves before the engine runs it, and runOutlineConformance checks both engines against them. actionTreeOf gives the action tree a link target is written as. The cloud wire carries the outline plane: LayerScopes.outline, outlineVersion in the manifest and in CacheDelta, and the outline and layer-outline resources.

• #890 by @bobsingor – Page structure edits are change ops: pages.rotate, pages.reorder, pages.delete, pages.insertBlank and pages.insert, each recorded with its reverse, so doc.apply({ undoOf }) undoes and redoes them. An undo of a delete brings the same pages back under the same refs, with their annotations and names, and publishes pages.restored. pageVerbs() makes the structure verbs of doc.pages one-op changes, so each verb's opId undoes it. wirePaths and wireTemplates no longer list the single page write routes.

• #883 by @bobsingor – pages.extract(pages, options) makes a copy of the pages as they draw: { flatten: { usage: 'print' } } is a print copy, with the annotations and form fields that print painted into the pages, nothing interactive left and layers in their print state; flatten: {} is the copy as shown on screen. includeAnnotations and includeFormFields choose what is painted, with a page picture's defaults, and are refused without flatten. A flattened copy needs doc.download or doc.download.flattened, and paints only what the caller may read; resolvePageExtract() is that check, shared by both engines. The wire schema of POST …/pages/extract takes the options, and runPrintCopyConformance checks a print copy against the print picture on any engine.

• #883 by @bobsingor – Page pictures can be made for paper. usage: 'print' with viewport: { kind: 'dpi', dpi: 150 | 300 } draws the page by the print rules: layers in their print state, and only the annotations and form fields with the print flag (no-view ones included, hidden ones never). The DPI counts on the paper the page prints on, A4 or Letter: a bigger page gets no more pixels than it needs shrunk to fit. A print picture is the whole page, upright, on white, so it takes no target, rotation or background, and a dpi viewport is for print pictures only. It needs doc.print, and 300 DPI doc.print.high.

  • Options: PageRenderOptions gains usage, and PageRenderViewport the dpi kind; PageScreenViewport is the screen sizes alone, which appearance renders take. checkRenderUsage() checks a render's usage, and the caller's rights when it knows them; printDpiOf() reads a print picture's DPI. PrintDpi and PagePrintRights name them.
  • Size: renderSize() and pageTransform() size a dpi viewport for its paper (printScale(), PRINT_PAPER).
  • Paths: each picture family has a print family at each tier, render/print/… (doc.print) and render/print-high/… (doc.print.high), with the family's planes and pins. The tier is a right, so it is a path of its own, and the CDN signs it only for a session with that right. PAGE_PRINT_FAMILIES, PAGE_PICTURES, pagePictureOf(), wirePaths.docPagePrint, layerPagePrint and their …Current twins, and PagePrintQuerySchemas.
  • Conformance: runPrintRenderConformance and its fixture PRINT_RULES_PDF.

• #891 by @bobsingor – A change crosses the worker in page space both ways (DocumentApplyWorkerRequest, DocumentApplyChangesWorkerRequest, ServerChange, ServerChangeOutcome lose their coordinates parameter): each op is measured on the document as the ops before it left it, so one change can annotate a page and then delete it, or make a page and annotate it. The single page routes' input schemas (PageReorderInputSchema, PageRotateInputSchema, PageDeleteInputSchema, PageInsertInputSchema, PageInsertBlankInputSchema) are gone with the routes. The change conformance covers the new cases on both engines.

• #895 by @bobsingor – Signature change analysis handles loops of unchanged objects (structure trees, outlines, popups) in one pass. A comment added to a tagged PDF (Chrome, Word) after an approval signature now reads permitted instead of indeterminate. In ObjectReferrer labels, … stands for a route inside a loop, as in StructTreeRoot/…/Pg.

• #891 by @bobsingor – On the local engine, doc.attachments.create() and delete() are changes that can be undone, and a download of a file (an attachment, or an annotation's file) that decodes to more than 256 MB is refused with PayloadTooLarge, so a small compressed file can't take the tab down.

• #885 by @bobsingor – doc.outline on the local engine: read the document's outline and create, update, move and delete its items as undoable changes.

• #890 by @bobsingor – On the local engine, doc.pages.rotate(), reorder(), delete(), insert() and insertBlank() are changes that can be undone.

• #883 by @bobsingor – The local engine's pages.extract(pages, options) makes flattened copies: { flatten: { usage: 'print' } } returns the pages as they print, painted in, with nothing interactive left. It needs doc.download or doc.download.flattened, and paints only what the caller may read.

• #883 by @bobsingor – page.render.image() and render.raw() make print pictures (usage: 'print', viewport: { kind: 'dpi', dpi: 150 | 300 }): drawn by the print rules, sized for the paper, refused without doc.print (or doc.print.high at 300 DPI). Print pictures are off the render lattice, so an enforced lattice doesn't refuse them.

• #878 by @bobsingor – The local engine no longer stalls when a call that every job waits for, such as engine.fonts.register(), is queued while a page read runs: a running read now gives way only to work that is more urgent than what waits behind it, so every queued call still gets its answer.

• #884 by @bobsingor – The engine's workers now start under next dev when Next.js compiles them, as it does for a package in transpilePackages or a linked copy outside node_modules. React Fast Refresh used to add $RefreshReg$ calls to workers/embedpdf-worker.js, which don't exist in a worker, so the viewer reported that the engine worker did not start. The worker is now a self-contained IIFE that Fast Refresh leaves alone, and the build checks that it stays that way. The image encoder worker now starts as a module worker, like the engine worker: Next.js appends import.meta code to it, which a classic worker can't parse, so encoding fell back to the main thread with a warning.

• #891 by @bobsingor – Binds the fork's attachment captures: EPDFAttachment_ExportRawToOwnedBuffer, EPDFAttachment_ImportRaw and EPDFAttachment_ExportCanonicalToOwnedBuffer.

• #885 by @bobsingor – The runtime's bindings name the outline editing functions (EPDFOutline_*), which address items by object number, keep /Count right and work inside layer transactions, and the outline capture functions used to undo a delete. The EPDFBookmark_* writers are gone.

• #891 by @bobsingor – The runtime's bindings name EPDFDoc_ExportDictCanonicalToOwnedBuffer: a dictionary and what the layer holds under it as bytes a guard compares, without the keys it is told to leave out and with each stream as it reads.

• #883 by @bobsingor – Bindings for the runtime's new functions, among them EPDFDoc_ExportPagesFlattened, which copies pages into a new document as they draw for display or print.

• #891 by @bobsingor – Attachment ops apply inside changes, with their reverses: a delete keeps the file so its undo puts it back under its name, and undoing an add leaves a file someone put under that name since, even with the same bytes. The attachments.create and attachments.delete worker jobs are removed. A decode refused past its limit names the limit (details.limit).

• #885 by @bobsingor – Read and write the document's outline in the worker: an outline reader with loop guards and read limits, the outline ops with undo (deleted items come back from a capture under the numbers they had), and the outline.read worker job. Link and outline targets share one writer, so an outline item's target is written as /A, as a link's is.

• #890 by @bobsingor – Page ops apply inside changes, with their reverses: a delete keeps each page so its undo puts it back where it was, and undoing an insert, a move or a turn leaves the pages someone changed since.

• #883 by @bobsingor – The worker's page extract makes flattened copies with the runtime's EPDFDoc_ExportPagesFlattened: annotations and form fields painted in as they draw for the usage (an annotation without a stored appearance included), no annotations or page actions left, layers in their state for the usage. Every extracted copy keeps the document's title.

• #883 by @bobsingor – The page renderer draws print pictures (usage: 'print'): with PDFium's printing flag, so layers take their print state and annotations and form fields draw by their print flag, sized by the picture's dpi viewport.

• #884 by @bobsingor – Rename DocumentSession.useObjectNumber() to claimObjectNumber(). It claims a number from the session's reserved object numbers for the open transaction, the counterpart of reserveObjectNumbers(). The old name read as a React hook, so dev tools that look for hooks rewrote the engine worker around it.

• #891 by @bobsingor – Undo fixes. Each op of a change converts to and from page space as it runs, so changes sent together (or ops of one change) that delete, make or bring back a page another one names apply instead of failing the job. Guards compare canonical bytes, which a save that only encodes a stream again, or the layer learning its file's hash, no longer changes: the undo of a page insert applies after the page was turned and turned back. The undo of opening an outline item counts the items above it again; the undo of a delete or move that emptied an open item opens it again; the undo of an item made applies after the page its target goes to was deleted; the undo of a retarget skips the target when its old page is gone. No outline item is made under the deepest item a read shows.

• #891 by @bobsingor – New entry @embedpdf/angular/attachment: withAttachment() and the EpdfAttachment service, with the files, the selected files, the load state, canAdd() and canDownload() as signals, the calls that select, add, remove, save and go to files, and changed$ and resynced$. Reading it reads the document's attachments.

• #885 by @bobsingor – @embedpdf/angular/outline: withOutline() and the EpdfOutline service for the document's outline (its bookmarks): its State table as signals (rows(), current(), canEdit(), …), its calls, and the streams changed$ and resynced$. Reading the service reads the outline.

• #876 by @bobsingor – Tapping a form field or editing a free text box on iOS no longer zooms the page in: their editors lay their text out at 16 px or more and draw it back at the page's size. [epdfRichTextEditor] now also makes your element fill its parent at that legible size, so draw the box's fill, border and padding on the parent: anything on the element itself scales with its text.

• #890 by @bobsingor – EpdfPageEdit has selected(), the selected pages as a signal, and select(pages). Page-edit positions are position now, in place of placement.

• #883 by @bobsingor – The runtime hands the kernel the browser's printer (browserPrinter() from @embedpdf/web), and the documents service has preparePrint(), print() and getPrintQuality().

• #895 by @bobsingor – A renderer that draws free text itself with [epdfRichTextEditor] shows the text of every text box, including the ones saved in the PDF. Before, a saved box that wasn't being edited drew empty until it was double-clicked. Typing in such a box works too: the element takes focus when editing starts, where before the keys went to the page.

• #891 by @bobsingor – New entry @embedpdf/react/attachment: useAttachment(), useAttachmentState() (the files, the load state, canAdd, canDownload) and useAttachmentEvent() for @embedpdf/plugin-attachment. Reading the state reads the document's attachments.

• #885 by @bobsingor – @embedpdf/react/outline: useOutline(), useOutlineState() and useOutlineEvent() for the document's outline (its bookmarks), with the plugin and its types. Reading the state reads the outline.

• #876 by @bobsingor – Tapping a form field or editing a free text box on iOS no longer zooms the page in: their editors lay their text out at 16 px or more and draw it back at the page's size. useRichTextEditor()'s style now also makes your element fill its parent at that legible size, so draw the box's fill, border and padding on the parent: anything on the element itself scales with its text.

• #890 by @bobsingor – usePageEditState() returns the page edits' state: selected, canEdit and canExtract. It takes a selector. Page-edit positions are position now, in place of placement.

• #883 by @bobsingor – The runtime hands the kernel the browser's printer (browserPrinter() from @embedpdf/web), so documents.print() and preparePrint() print.

• #895 by @bobsingor – A renderer that draws free text itself with useRichTextEditor() shows the text of every text box, including the ones saved in the PDF. Before, a saved box that wasn't being edited drew empty until it was double-clicked.

• #891 by @bobsingor – New entry @embedpdf/svelte/attachment: useAttachment(), useAttachmentState() (the files, the load state, canAdd, canDownload) and useAttachmentEvent() for @embedpdf/plugin-attachment. Reading the state reads the document's attachments.

• #885 by @bobsingor – @embedpdf/svelte/outline: useOutline(), useOutlineState() and useOutlineEvent() for the document's outline (its bookmarks), with the plugin and its types. Reading the state reads the outline.

• #876 by @bobsingor – Tapping a form field or editing a free text box on iOS no longer zooms the page in: their editors lay their text out at 16 px or more and draw it back at the page's size. useRichTextEditor()'s style now also makes your element fill its parent at that legible size, so draw the box's fill, border and padding on the parent: anything on the element itself scales with its text.

• #890 by @bobsingor – usePageEditState() returns the page edits' state as a reactive object: selected, canEdit and canExtract. It takes a selector. Page-edit positions are position now, in place of placement.

• #883 by @bobsingor – The runtime hands the kernel the browser's printer (browserPrinter() from @embedpdf/web), so documents.print() and preparePrint() print.

• #895 by @bobsingor – A renderer that draws free text itself with useRichTextEditor() shows the text of every text box, including the ones saved in the PDF. Before, a saved box that wasn't being edited drew empty until it was double-clicked.

• #891 by @bobsingor – New entry @embedpdf/vue/attachment: useAttachment(), useAttachmentState() (the files, the load state, canAdd, canDownload, as refs) and useAttachmentEvent() for @embedpdf/plugin-attachment. Reading the state reads the document's attachments.

• #885 by @bobsingor – @embedpdf/vue/outline: useOutline(), useOutlineState() and useOutlineEvent() for the document's outline (its bookmarks), with the plugin and its types. Reading the state reads the outline.

• #876 by @bobsingor – Tapping a form field or editing a free text box on iOS no longer zooms the page in: their editors lay their text out at 16 px or more and draw it back at the page's size. useRichTextEditor()'s style now also makes your element fill its parent at that legible size, so draw the box's fill, border and padding on the parent: anything on the element itself scales with its text.

• #890 by @bobsingor – usePageEditState() returns the page edits' state as refs: selected, canEdit and canExtract. It takes a selector. Page-edit positions are position now, in place of placement.

• #883 by @bobsingor – The runtime hands the kernel the browser's printer (browserPrinter() from @embedpdf/web), so documents.print() and preparePrint() print.

• #895 by @bobsingor – A renderer that draws free text itself with useRichTextEditor() shows the text of every text box, including the ones saved in the PDF. Before, a saved box that wasn't being edited drew empty until it was double-clicked.

• #876 by @bobsingor – Editors on a page no longer make iOS Safari zoom the page in when they take focus. A text field's editor (textFieldEditorStyleOf()) and a free text box's editor lay their text out at 16 px or more and draw it back at the page's size with a transform, so they look the same in every browser. New: freeTextBoxOf(), the layer's own text box (its place on the plate, its turn and its style, in place of textPlateInPixels()); ownTextBoxOf(), your own element as a text box's editor, filling its parent; legibleScaleOf(), legibleShrinkOf(), LEGIBLE_FONT_PX and textFieldFontPxOf(). textFieldStyleOf() takes the legible scale. textPlateInPixels(), TextPlatePixels and the textBoxStyleOf() export are removed.

• #883 by @bobsingor – Add browserPrinter(), the browser's print dialog for createKernel({ printer }). Where the browser's own PDF viewer prints PDFs (a desktop browser with it on), it prints the kernel's PDF copy from a hidden frame, keeping the frame until the next PDF so the browser can finish; a print the browser refuses rejects, so the kernel prints pictures instead. Everywhere else it prints pictures: one sheet per page, sized to the page with a named @page, from a hidden frame, or from the page itself on iOS, which prints a frame as a picture of the page around it. In Safari's engine it needsTap: Safari prints only from a tap (later, iOS refuses the print dialog and the Mac prints blank pages). standardCommandsBrowser no longer has print: printing goes through the kernel.

• #885 by @bobsingor – An action can come from an outline item: ActionSource and ActionTreeSource gain { kind: 'outline', item }, and a script an outline item runs sees event.type 'Bookmark', as in Acrobat.

• #883 by @bobsingor – The document's print actions run around the kernel's print. The plugin registers ctx.aroundPrint, so WillPrint and DidPrint run around every print dialog, and a Named Print action or a script's this.print() prints through documents.print() when the kernel has a printer (a print a script starts without a user's tap stays refused). Without a printer, the UI adapter's print() is used as before.

• #895 by @bobsingor – New host read getTextItem(ref, view?): one free text's text item (its runs, body style and box) in every state, saved and idle included. A renderer that draws a text box itself reads it, since no engine picture is drawn under its element. listTextItems is unchanged: it lists only the text boxes the layer draws as elements.

• #890 by @bobsingor – The annotations of pages an undo brings back are read again.

• #891 by @bobsingor – When pages go, come or come back, the pages whose annotations link to them are read again, so a link to a deleted page that an undo brought back works again.

• #891 by @bobsingor – New plugin: the files a document carries. attachmentPlugin() lists them as one list: the document's attachments, read when something asks (ensureLoaded(), or reading attachmentState), then the files of its file attachment annotations, from the annotation plugin. add() attaches files as one undoable change, giving a name the document has already a number (notes (2).txt), and shows them at once; remove() takes an attachment, or a page's file attachment annotation, away as one undoable step, and an undo draws the file back before the engine answers. download() returns a file's bytes with its name cleaned of control and bidi characters (displayNameOf) and its type; reveal() goes to a page's file, and select() / getSelected() keep the files a panel's commands act on. canAdd(), canRemove() and canDownload() answer what the session may do.

• #883 by @bobsingor – document:print prints the document in scope through the kernel's documents.print(), which runs the document's own print actions around the dialog. StandardCommandsPlatform no longer has print, and the package no longer depends on @embedpdf/plugin-actions.

• #885 by @bobsingor – resolveLinkTarget(target, hasPage) from @embedpdf/plugin-link/contract is the rule resolve() follows, for anything else that follows link targets, such as outline items.

• #885 by @bobsingor – New plugin: the document's outline (its bookmarks). outlinePlugin() mirrors the outline from the engine, reading it when something asks (ensureLoaded(), or reading outlineState), and shows this session's pending edits at once. It keeps which items are expanded (starting from the items the file opens) and which are selected, lists the rows a tree view shows (listRows()), names the item for where the view is reading (getCurrentItem()), and follows an item as a click does (activate()). create, update, move and delete are each one undoable change; a new item goes to the place in view and takes the selected text, or "Untitled" in the viewer's language, as its title. canEdit() answers whether the session may change the outline.

• #890 by @bobsingor – The outline is read again when an undo brings pages back, so the items that go to them work again.

• #890 by @bobsingor – Page edits are steps of the history, and the plugin keeps the page selection.
  • Every edit is one change on the document's queue (ctx.changes), so undo puts the pages back as they were: a moved page goes back to its place, a deleted page comes back under its ref with its annotations, inserted pages go. rotateBy turns from the rotation the edits on their way give a page, so two quick quarter turns are a half turn. duplicate() and extract() copy the pages as they show, after the edits made before them.
  • getSelected() and select(pages) hold the selected pages, and pageEditState declares selected, canEdit and canExtract for the framework hooks. A page that's deleted leaves the selection.
  • placement is now position, and a position is the engine's PagePosition: { after: pageRef }, { before: pageRef }, 'start' or 'end'. PagePlacement and PagePlacementOptions are gone (PagePositionOptions).

• #885 by @bobsingor – getCurrentDestination() says where the view is as a destination: the page reaching past the top of the view, the point where goToDestination() puts one (a padding in from the top-left), and no zoom, so going there again keeps the reader's zoom.

• #891 by @bobsingor – The attachments panel: the files the document carries, its attachments and then the files on its pages, each with its kind, its name (without the characters that can disguise one), its size, its page and its description. Clicking an attachment saves it, clicking a page's file goes to it, and a row's menu saves, goes to the page and deletes, each as one undoable step. Add file in its header, or files dropped on it, attach them, a name the document has already getting a number. The outline and attachments panels show while they have a job: their list holds entries, or the session may add some with the feature on. A selected file attachment annotation's strip has Save file (annotation:save-file). New commands attachment:add, attachment:save, attachment:go-to, attachment:delete and the attachment-item menu.

• #885 by @bobsingor – The Outline panel shows the document's bookmarks as a tree, beside Thumbnails, for every document (one without an outline says so). A row goes where its item goes; the item for where you are reading is marked and scrolls into view; a filter finds items by their title, in their place; the keyboard works the tree as the ARIA tree pattern does. A session that may change the outline adds items (Mod+B, after the selected one, at the place in view, renaming at once), renames them in their row, drags them to another place and level, deletes them, and edits an item's title, colour, style, open state and destination in its Properties. Each edit is one step of the history. The new outline:* commands and the outline-item menu are in the layout, and outline.editing is a feature readOnly turns off. The page number field gives focus back to the number in the same frame it closes.

• #890 by @bobsingor – Pages are organized in the thumbnails panel, where the user may change them (pages feature, doc.pages.assemble).

  • A click selects a page and goes to it; Ctrl/Cmd+click and Shift+click select more. Each page has a menu (its ⋯ button, a right-click or a long press) with rotate, insert a blank page or a PDF, duplicate, extract and delete. Dragging moves pages, with a line where they land; a PDF dropped between pages is inserted there instead of opening as a tab. The arrows, Shift, Space, Alt+arrows, Delete and Ctrl/Cmd+A work while the list has focus.
  • The panel's header inserts a blank page, rotates and deletes the selection, opens its menu, and has undo and redo: every page edit is a step of the history.
  • New commands: page:rotate-clockwise, page:rotate-counterclockwise, page:delete, page:duplicate, page:insert-blank, page:insert-file (args: { position, files }), page:extract (in documents.download, so readOnly keeps it), page:select-all and menu:page, with the page menu. New icons: pageRotateClockwise, pageRotateCounterClockwise, filePlus, fileExport. Their strings are in all 13 languages.
  • Downloads of the document, a stamp library, a signature and a signed revision share one way of saving a file.

• #883 by @bobsingor – Print (document:print, Ctrl/Cmd+P) opens a Print dialog: every page, the current page or pages such as 1-3, 5, and whether annotations print. Nothing is made while the user chooses: Print prepares the chosen pages, shows how far it is with a progress bar (Cancel stops it), and opens the browser's print dialog when they're ready. In Safari, which prints only from a tap, it says the pages are ready and prints from the next tap on Print. It says when the document allows only low-resolution printing. In every language the viewer ships.

• #876 by @bobsingor – With a finger as the main way of pointing, the viewer's own fields (search, the page number, comments, signatures and the rest) write in 16 px text, so iOS Safari doesn't zoom the page in when one takes focus.

• #872 by @bobsingor – Fix sheets on a phone: a menu or panel sheet slides straight up from the bottom of the viewer instead of landing too high and dropping into place, and the whole viewer stays dimmed behind it while it slides in or is dragged. Dragging a sheet's handle down fades the dimming with it, and the dimming returns when the sheet is let go at rest.

• #891 by @bobsingor – The viewer brings the attachment plugin: viewer.get('attachment') lists, adds, removes and saves the files a document carries, and the sidebar has the attachments panel.

• #885 by @bobsingor – The viewer includes the outline plugin and its panel: viewer.get('outline') reads and edits the document's bookmarks.

• #895 by @bobsingor – AFDate_FormatEx reads a date in the field's own format before trying a JavaScript date, as Acrobat does. A dd/mm/yyyy field showing 12/02/2027 stays 12 February instead of turning into 02/12/2027.

• #890 by @bobsingor – The form is read again when an undo brings pages back.

• #885 by @bobsingor – EmbedPDF's strings include outline.untitled, the title of a new outline item, in all eight languages.

October 25, 2026

• Fixed events getting stuck semi-transparent after a drag or resize is interrupted by the browser (689)

Special thanks to the following sponsors of EventСalendar:

@ekwi-tech @syncsynchalt @aurawindsurfing

• release: switch to trusted publishing (65a579f)

• release: switch to trusted publishing (5cb7a32)

更新内容请查看CHANGELOG。 Please refer to CHANGELOG for details.

• docs(contributing): ask for issues instead of RPs https://github.com/honojs/hono/pull/5526
• docs(readme): sync the contributing list with CONTRIBUTING.md https://github.com/honojs/hono/pull/5527
• fix(adapters): accept Hono v5 prereleases in the hono peer range https://github.com/honojs/hono/pull/5537
• chore: unified oxfmt and oxlint config https://github.com/honojs/hono/pull/5518
• docs(readme): remove the deepwiki badge https://github.com/honojs/hono/pull/5548
• fix(serve-static): only serve GET and HEAD requests https://github.com/honojs/hono/pull/5514
• fix(build): keep barrel imports in the bundled d.ts https://github.com/honojs/hono/pull/5557
• fix(jsx): preserve self-closing void elements in cloneElement https://github.com/honojs/hono/pull/5314
• fix(css): keep "//" inside an unquoted url() when minifying https://github.com/honojs/hono/pull/5450
• fix(css): keep the descendant combinator before a pseudo-class when minifying https://github.com/honojs/hono/pull/5451
• fix(serve-static): respect q-values in Accept-Encoding for precompressed files https://github.com/honojs/hono/pull/5436
• fix(helper/route): match regex params in basePath() the same way as the router https://github.com/honojs/hono/pull/5498
• fix(trie-router): keep first value for duplicate path params https://github.com/honojs/hono/pull/5423
• fix(hono-base): disallow getPath when strict is false https://github.com/honojs/hono/pull/5563
• fix(css): Fix multiline CSS handling in style replacement https://github.com/honojs/hono/pull/5405
• feat(bearer-auth): allow MessageFunction to return a Response https://github.com/honojs/hono/pull/5269
• fix(utils/url): preserve encoded duplicate query order https://github.com/honojs/hono/pull/5495

Full Changelog: https://github.com/honojs/hono/compare/v4.13.13...v4.13.14

• Build the inline Flight script from React's strings instead of re-encoding them: #100142
• Fix dist dir lockfile on filesystems with no or limited lockfile implementations (e.g. NFS): #100684

• perf(turbopack): look up chunk group indices through a keyed cell: #99050
• Turbopack: track availability by chunk group: #98685
• refactor(turbopack): chunk chunk groups by key: #99750
• Turbopack: consume graph-derived chunk groups: #98734
• turbo-tasks-backend: stripe SnapshotCoordinator's operation count and poll for the drain: #100280
• turbo-tasks-backend: parallelize decoding of large batch lookups: #100453
• turbo-persistence: don't shrink the shard count before the first bottom merge: #100424

Huge thanks to @sokra, @lukesandberg, @gaearon, and @bgw for helping!

A minor release: fixes and features from a batch of 29 issues (#5363 to #5391), plus five contributor PRs.

Behaviour changes to check when upgrading:

• Trellis panels no longer reserve the empty title band above each plot. Other charts keep it; the grid.padding docs in the types say how far it can be pulled in.
• Horizontal bar charts thin overlapping category names instead of drawing them over each other.
• stackType 100% area and line charts now draw percentages, as 100% bars already did.

Also new:

• radialBar targets ship as an add-on: import apexcharts/features/radial-targets (the full bundle includes it).
• The plugin API's dashArray now also carries pattern strings and per-series patterns, so a plugin that assumed a number should handle those.
• Legend and keyboard announcements are translated in every locale. The translations have not had a native-speaker review, so corrections are welcome.

• Full dash patterns everywhere, line caps on annotations (#5383).
• Trellis panels drop the empty title band above each plot.
• Thin overlapping category names on horizontal bar charts (#5371).
• A balanced hide order for overlapping labels (#5378).
• Tooltip.visible false keeps hover without the box (#5382).
• Band gap units, radial geometry for plugins, targets add-on (#5374, #5380, #5381).

• Keep points appended to a hidden series (#3200). Thanks @lbesecker195.
• Ignore chart click when a selection drag ends (#5060). Thanks @itisrmk.
• Don't draw end dots for a null row (#4458). Thanks @b84330808.
• Blend colour scale stops written with a hex alpha. Thanks @Enesuygurs.
• End a derived linear scale exactly on its max. Thanks @Pharex38.
• Fade a faded whole's own stroke when there is no outline. Thanks @lazerg.
• Fire marker hover and selection events. Thanks @lazerg.
• Honour avoidOverlap.maxShift of 0. Thanks @lazerg.
• Apply legend.labels.colors to the shared legend. Thanks @lazerg.
• Hide a stacked column label that is wider than its column. Thanks @lazerg.
• Keep a covered whole's stroke through the pick and clear frames. Thanks @lazerg.
• Clear the zoomed flag when updateSeries resets the axes. Thanks @lazerg.
• UpdateOptions({ trellis: null }) turns the grid back into one chart. Thanks @lazerg.
• Keep the label of a part of 0 on a stacked bar. Thanks @lazerg.
• Clear row and column when trellis is set to null. Thanks @lazerg.
• Keep the grid when two updateOptions calls land in one task. Thanks @lazerg.
• Warn instead of throwing when the chart type has no annotation groups. Thanks @lazerg.
• Measure a vertical stacked column label across the column. Thanks @lazerg.
• Use chart.fontFamily and legend.fontFamily in the HTML chrome. Thanks @lazerg.
• Place a zero part's label at its part edge. Thanks @lazerg.
• Remove the Reset Zoom button when updateSeries clears the zoom. Thanks @lazerg.
• Count exponent-notation decimals in preciseAddition. Thanks @Pharex38.
• Use stepSize when it divides a fixed min..max window. Thanks @Pharex38.
• Translate legend and keyboard announcements, fill locale gaps (#5373, #5376).
• Warn when a needle gauge overrides the indicator (#5385).
• Keep a hidden series' stroke as drawn with an outline on.
• Keep the zoomed view across internal updates and on y for xy (#5389, #5369).
• Keep the edge columns inside the plot while zoomed (#5368).
• Draw stackType 100% area and line charts as percentages (#5384).
• Rotate and thin category labels against the drawn plot (#5370).
• Never rotate radar category names.
• ResetSeries keeps a legend-hidden series after appendData.

The default bundle is 275,373 B gzipped, up 2,798 B (1.0%) from 8.4.1. The full bundle is 400,755 B gzipped, up 5,279 B (1.3%) from 8.4.1.

Upgrading is npm install apexcharts@8.5.0.

Full changelog, with the detail behind each change: https://github.com/apexcharts/apexcharts.js/compare/v8.4.1...v8.5.0