• Fix workspace showing an internal error when syncing components or dragging in the color picker #11933 (PR: #11941)
• Fix SVG sanitizer keeping namespace-prefixed script elements when uploading SVG files #12071 (PR: #12073)

View changelog with demos on mantine.dev website

You can now sponsor Mantine development with OpenCollective. All funds are used to improve Mantine and create new features and components.

@mantine/mcp-server now exposes 406 documentation pages instead of 164. Previously only components were indexed – hooks, @mantine/form, styling, theming, guides and help.mantine.dev FAQ pages are now included as well. Changelog pages are deliberately excluded to keep search results focused on current APIs.

Documentation is now retrieved by section rather than by whole page. get_item_doc returns a page outline (description, import statement and the list of section headings) by default, a single section with the section argument, or the entire page with full: true. Requesting useForm this way returns about 1KB instead of 9KB, and the largest pages drop from roughly 89KB to 4KB.

Other improvements:

• New get_api tool – resolves a symbol such as useForm or useDisclosure to its TypeScript signature and exported types without knowing which page documents it
• Ranked search – search_docs results point at the specific section that matched, so a query like "validate a form with zod" resolves to the zod section of the schema validation page
• Search synonyms – queries now match the search keywords maintained in the documentation, so "command palette" finds Spotlight
• More filters – list_items accepts group, category and package in addition to kind
• Hook signatures – get_item_props returns the TypeScript signature for hooks, and points at the relevant section for pages that document their API in prose

The server was also migrated to the official Model Context Protocol SDK, so the protocol version is negotiated with the client instead of being pinned.

For setup details, supported tools, and client-specific instructions, see Mantine with LLMs.

New Tour component provides interactive step-by-step application onboarding. It highlights target elements with a spotlight overlay and displays tooltips with navigation controls. Supports both guided (sequential) and beacon (non-sequential) modes.

New Toolbar component provides an accessible toolbar container with roving tabindex keyboard navigation, toggle groups with single/multiple selection, visual grouping, and dividers. Styling is similar to RichTextEditor toolbar.

New Toggle component is a button that can be toggled between active and inactive states:

New JsonViewer component can be used to display complex JSON structures with expand/collapse, type indicators, copy to clipboard, and other features:

Checkbox and Radio components now support variant="light" – the indicator uses a light background color with a colored icon, similar to the light variant available in other components like Button:

import { Radio, Checkbox, Stack } from '@mantine/core';

function Demo() {
  return (
    <Stack gap={7}>
      <Checkbox variant="light" label="Light Checkbox" defaultChecked />
      <Checkbox variant="light" label="Light indeterminate Checkbox" indeterminate />
      <Radio variant="light" label="Light Radio" defaultChecked />
    </Stack>
  );
}

RichTextEditor now supports image upload with loading states. Images can be uploaded via toolbar button, drag and drop, or paste. During upload, a local preview is shown with a loading indicator.

Configuring getUploadImageExtension is enough to enable uploads – onImageUpload and onImageUploadError props of RichTextEditor are optional overrides for the toolbar control. onImageUpload can resolve either to a string or to { src, alt, title } (new exported ImageUploadResult type) to set alternative text on the uploaded image. Several files picked, dropped or pasted together are inserted in the order they were selected and are undone as one step.

import TipTapImage from '@tiptap/extension-image';
import { useEditor } from '@tiptap/react';
import StarterKit from '@tiptap/starter-kit';
import { getUploadImageExtension, ImageUploadResult, RichTextEditor } from '@mantine/tiptap';

function handleImageUpload(file: File): Promise<ImageUploadResult> {
  return new Promise((resolve) => {
    setTimeout(() => {
      resolve({ src: URL.createObjectURL(file), alt: file.name });
    }, 3000);
  });
}

function Demo() {
  const editor = useEditor({
    shouldRerenderOnTransaction: true,
    extensions: [
      StarterKit,
      getUploadImageExtension(TipTapImage, { onImageUpload: handleImageUpload }),
    ],
    content: '<p>Click the image button in the toolbar, or drag & drop / paste an image into the editor.</p>',
  });

  return (
    <RichTextEditor editor={editor}>
      <RichTextEditor.Toolbar>
        <RichTextEditor.ControlsGroup>
          <RichTextEditor.Bold />
          <RichTextEditor.Italic />
        </RichTextEditor.ControlsGroup>

        <RichTextEditor.ControlsGroup>
          <RichTextEditor.ImageUpload />
        </RichTextEditor.ControlsGroup>
      </RichTextEditor.Toolbar>

      <RichTextEditor.Content />
    </RichTextEditor>
  );
}

DayView and WeekView now support eventOverlapMode prop that controls how events overlapping in time share the horizontal space. The default columns mode splits the available width evenly between them, which becomes unreadable once a large number of events overlap. The new cascade mode indents each event and stacks it over the previous one, so every event keeps a readable width no matter how many of them overlap.

The indent shrinks automatically as the group grows, so the event on top always keeps at least 60% of the available width. Covered events can still be read and used: rest the pointer on one and it is raised above the events covering it, which also makes its resize handles reachable. Keyboard users get the same result by focusing the event with Tab. eventOverlapRaiseDelay prop controls how long the pointer must rest on an event before it is raised, in milliseconds (600 by default).

import { useState } from 'react';
import { SegmentedControl, Stack } from '@mantine/core';
import { ScheduleEventOverlapMode, WeekView } from '@mantine/schedule';
import { events } from './data';

function Demo() {
  const [mode, setMode] = useState<ScheduleEventOverlapMode>('cascade');

  return (
    <Stack>
      <SegmentedControl
        value={mode}
        onChange={(value) => setMode(value as ScheduleEventOverlapMode)}
        data={[
          { value: 'columns', label: 'columns' },
          { value: 'cascade', label: 'cascade' },
        ]}
      />

      <WeekView
        date={new Date()}
        events={events}
        startTime="08:00:00"
        endTime="14:00:00"
        eventOverlapMode={mode}
      />
    </Stack>
  );
}

All Schedule views can now reject a drag or resize before it is committed, based on where the event is being dropped rather than on which event is being dragged. Previously canDragEvent and canResizeEvent only decided whether an event was draggable or resizable at all, so the only way to prevent a double booking was to accept the drop, notice the conflict in the handler and not update state – which produced a snap-back with no explanation:

• preventEventOverlap rejects placements that would make the event overlap another event. Pass a function to decide per pair of events: return true to forbid that particular overlap.
• canDropEvent and canResizeEventTo are called before a drop or resize is committed – return false to reject it.
• canDropExternalEvent does the same for items dragged in from outside the schedule.
• onEventPlacementRejected reports the rejection with the conflicting events and the reason.

The checks compose: a placement is allowed only when the overlap check passes and the matching callback returns a value other than false. The overlap check runs first, so onEventPlacementRejected can report conflicts without your code repeating the work. While the pointer is over an invalid target the drag ghost and the resizing event get data-invalid, so the rejection is visible before the pointer is released.

import { useState } from 'react';
import dayjs from 'dayjs';
import { Stack, Text } from '@mantine/core';
import { WeekView, ScheduleEventData } from '@mantine/schedule';

const startOfWeek = dayjs()
  .subtract((dayjs().day() + 6) % 7, 'day')
  .format('YYYY-MM-DD');

const initialEvents: ScheduleEventData[] = [
  {
    id: 1,
    title: 'Standup',
    start: `${startOfWeek} 09:00:00`,
    end: `${startOfWeek} 09:30:00`,
    color: 'blue',
  },
  {
    id: 2,
    title: 'Design review',
    start: `${startOfWeek} 11:00:00`,
    end: `${startOfWeek} 12:00:00`,
    color: 'grape',
  },
  {
    id: 3,
    title: 'Retro',
    start: `${startOfWeek} 14:00:00`,
    end: `${startOfWeek} 15:00:00`,
    color: 'teal',
  },
];

function Demo() {
  const [date, setDate] = useState(dayjs().format('YYYY-MM-DD'));
  const [events, setEvents] = useState(initialEvents);
  const [message, setMessage] = useState<string | null>(null);

  return (
    <Stack>
      <WeekView
        date={date}
        onDateChange={setDate}
        events={events}
        startTime="08:00:00"
        endTime="18:00:00"
        withEventsDragAndDrop
        withEventResize
        eventDragInterval={15}
        preventEventOverlap
        onEventDrop={({ eventId, newStart, newEnd }) => {
          setMessage(null);
          setEvents((prev) =>
            prev.map((event) =>
              event.id === eventId ? { ...event, start: newStart, end: newEnd } : event
            )
          );
        }}
        onEventResize={({ eventId, newStart, newEnd }) => {
          setMessage(null);
          setEvents((prev) =>
            prev.map((event) =>
              event.id === eventId ? { ...event, start: newStart, end: newEnd } : event
            )
          );
        }}
        onEventPlacementRejected={(data) => {
          if (data.action === 'external-drop') {
            return;
          }

          setMessage(
            `${data.event.title} cannot be ${data.action === 'drop' ? 'moved' : 'resized'} there – it would overlap ${data.conflicts
              .map((conflict) => conflict.title)
              .join(', ')}`
          );
        }}
      />

      {message && <Text c="red" size="sm">{message}</Text>}
    </Stack>
  );
}

In resource views the conflict set is scoped to the target resource, so moving an event onto another resource row is checked against that row rather than the one it came from:

import { useState } from 'react';
import dayjs from 'dayjs';
import { Stack, Text } from '@mantine/core';
import { ResourcesDayView, ScheduleEventData, ScheduleResourceData } from '@mantine/schedule';

const today = dayjs().format('YYYY-MM-DD');

const resources: ScheduleResourceData[] = [
  { id: 'room-a', label: 'Room A' },
  { id: 'room-b', label: 'Room B' },
  { id: 'room-c', label: 'Room C (large groups only)' },
];

const initialEvents: ScheduleEventData[] = [
  {
    id: 1,
    title: 'Interview (2 people)',
    start: `${today} 09:00:00`,
    end: `${today} 10:00:00`,
    color: 'blue',
    resourceId: 'room-a',
    payload: { attendees: 2 },
  },
  {
    id: 2,
    title: 'All-hands (40 people)',
    start: `${today} 11:00:00`,
    end: `${today} 12:00:00`,
    color: 'grape',
    resourceId: 'room-c',
    payload: { attendees: 40 },
  },
];

function Demo() {
  const [date, setDate] = useState(dayjs().format('YYYY-MM-DD'));
  const [events, setEvents] = useState(initialEvents);
  const [message, setMessage] = useState<string | null>(null);

  return (
    <Stack>
      <ResourcesDayView
        date={date}
        onDateChange={setDate}
        resources={resources}
        events={events}
        startTime="08:00:00"
        endTime="18:00:00"
        withEventsDragAndDrop
        preventEventOverlap
        canDropEvent={({ event, resourceId }) =>
          resourceId !== 'room-c' || (event.payload?.attendees ?? 0) >= 20
        }
        onEventDrop={({ eventId, newStart, newEnd, resourceId }) => {
          setMessage(null);
          setEvents((prev) =>
            prev.map((event) =>
              event.id === eventId
                ? { ...event, start: newStart, end: newEnd, resourceId }
                : event
            )
          );
        }}
        onEventPlacementRejected={(data) => {
          if (data.action === 'external-drop') {
            return;
          }

          setMessage(
            data.reason === 'overlap'
              ? `${data.event.title} would overlap ${data.conflicts.length} event(s) in that room`
              : 'Room C is reserved for meetings with 20 or more attendees'
          );
        }}
      />

      {message && <Text c="red" size="sm">{message}</Text>}
    </Stack>
  );
}

TreeSelect now supports renderPill prop to customize how pills are rendered for selected values in multiple and checkbox modes, similar to renderPill prop of MultiSelect. The callback receives the tree node, so pills can use nodeProps or the node structure, for example to show a different icon for parent and leaf nodes:

import { FileTextIcon, FolderSimpleIcon } from '@phosphor-icons/react';
import { Group, Pill, TreeSelect, TreeSelectProps } from '@mantine/core';
import { data } from './data';

const renderTreePill: TreeSelectProps['renderPill'] = ({ node, onRemove, disabled, readOnly }) => (
  <Pill withRemoveButton={!readOnly} onRemove={onRemove} disabled={disabled}>
    <Group gap={4} wrap="nowrap">
      {node.children || node.hasChildren ? (
        <FolderSimpleIcon size={12} />
      ) : (
        <FileTextIcon size={12} />
      )}
      {node.label}
    </Group>
  </Pill>
);

function Demo() {
  return (
    <TreeSelect
      mode="checkbox"
      checkedStrategy="parent"
      label="Categories"
      placeholder="Pick categories"
      data={data}
      defaultValue={['phones', 'headphones']}
      defaultExpandAll
      renderPill={renderTreePill}
    />
  );
}

Tooltip now supports hideDetached prop, which works the same way as Popover hideDetached. It is enabled by default: the tooltip is now hidden when its target element is removed from the DOM, hidden with display: none, or scrolled out of a container that clips it. Previously, the tooltip stayed in place, floating over unrelated content. Set hideDetached={false} to restore the previous behavior. The prop has no effect on Tooltip.Floating, which is positioned relative to the mouse pointer.

Note that jsdom reports zero-size rectangles for every element, so in Jest and Vitest every tooltip is treated as detached and hidden unless the test wrapper sets env="test" on MantineProvider (as described in the Jest and Vitest guides) or the component is rendered with hideDetached={false}.

import { Box, Button, Group, Tooltip } from '@mantine/core';

function Demo() {
  return (
    <Box
      bd="1px solid var(--mantine-color-dimmed)"
      p="xl"
      w={{ base: 340, sm: 400 }}
      h={200}
      style={{ overflow: 'auto' }}
    >
      <Box w={1000} h={400}>
        <Group>
          <Tooltip label="Hidden when detached" position="bottom" opened>
            <Button>Hides when detached</Button>
          </Tooltip>

          <Tooltip label="Visible when detached" position="bottom" opened hideDetached={false}>
            <Button>Stays visible</Button>
          </Tooltip>
        </Group>
      </Box>
    </Box>
  );
}

Notifications now support withAutoCloseProgress prop. When set, a progress line that fills up until the notification auto closes is displayed at the bottom of every notification. The line fades out while the auto close timer is paused (for example, when the notification is hovered), starts over when the timer restarts, and uses the notification color. The prop sets the default for all notifications, it can be overridden for individual notifications with withAutoCloseProgress property in notifications.show and notifications.update functions:

import { Button, Group } from '@mantine/core';
import { notifications } from '@mantine/notifications';

function Demo() {
  return (
    <Group justify="center">
      <Button
        onClick={() =>
          notifications.show({
            title: 'Auto close progress',
            message: 'This notification will close in 5 seconds',
            withAutoCloseProgress: true,
            autoClose: 5000,
          })
        }
      >
        Show notification with progress
      </Button>

      <Button
        color="red"
        onClick={() =>
          notifications.show({
            title: 'Something went wrong',
            message: 'Progress line uses notification color',
            color: 'red',
            withAutoCloseProgress: true,
            autoClose: 8000,
          })
        }
      >
        Red notification with progress
      </Button>
    </Group>
  );
}

New notifications.promise function displays a loading notification while a promise is pending and updates it with success or error state once the promise settles. success and error can be functions that receive the resolved value or the rejection reason:

import { Button, Group } from '@mantine/core';
import { notifications } from '@mantine/notifications';

function saveDocument(shouldFail: boolean) {
  return new Promise<{ name: string }>((resolve, reject) => {
    setTimeout(() => {
      if (shouldFail) {
        reject(new Error('Network error'));
      } else {
        resolve({ name: 'report.pdf' });
      }
    }, 2000);
  });
}

function Demo() {
  const save = (shouldFail: boolean) =>
    notifications.promise(saveDocument(shouldFail), {
      loading: {
        title: 'Saving document',
        message: 'Please wait, it will take a couple of seconds',
      },
      success: (value) => ({
        title: 'Document saved',
        message: `${value.name} was saved successfully`,
      }),
      error: (error) => ({
        title: 'Failed to save document',
        message: (error as Error).message,
      }),
    });

  return (
    <Group justify="center">
      <Button onClick={() => save(false)}>Save document</Button>
      <Button color="red" onClick={() => save(true)}>
        Save document (fails)
      </Button>
    </Group>
  );
}

AppShell now supports resizing AppShell.Navbar/AppShell.Aside horizontally and AppShell.Header/AppShell.Footer vertically. Pass a useAppShellResize hook instance to the resize prop to enable it for the configured sections – handles support mouse, touch and keyboard, and can report drag-to-collapse. Each section accepts a label option to localize the aria-label of its handle. See AppShell examples for more details.

Note that when the resize prop is used, --app-shell-* CSS variables are defined on the AppShell root element instead of :root, so they cannot be read from content rendered in a Portal, for example from a Modal or a Drawer.

• New mantine-tanstack-start-template and TanStack Start guide to set up Mantine in a TanStack Start application.
• vite-template now uses Vite+: Vite, Vitest, oxlint and oxfmt run through the vp CLI and are configured in vite.config.mjs.
• New StyleX guide explains how to style Mantine components with StyleX in a Vite application.

• HoverCard now opens on keyboard focus, closes with Escape or a press outside, and is announced by screen readers. New events, interactive, role and returnFocus props, and onDismiss callback.
• HoverCard no longer opens with a tap on touch devices. Set events={{ focus: false, touch: true }} and closeOnEscape={false} to restore the previous behavior.
• Checkbox and Radio variant="light" colors are resolved with theme.variantColorResolver, so any CSS color or theme color with a shade can be used.
• ActionBar with keepMounted now uses React Activity instead of display: none, so effects are paused while the bar is closed. Set transitionProps={{ keepMountedMode: 'display-none' }} to restore the previous behavior.
• Mantine skills for AI coding agents (mantine-form, mantine-combobox, mantine-custom-components) have been updated for 9.x with corrected API details and new patterns.
• Gatsby and Redwood guides have been removed, gatsby-template and redwood-template are no longer maintained. Existing applications can keep using Mantine, the setup does not change.

• feat: add editable vector export and enhance PDF capabilities 019603a
• feat(docs): refresh navigation and live demos bbc59da
• feat(plugins): add open-source vector export 299c561
• feat: improve plugin export contracts b828762
• feat: replace pdf-image with full PDF export 8acda94

• fix: one [SnapDOM] prefix and plain-language console messages bbde42f
• fix: center checkbox and radio replacements in a stretched box #516
• fix: halve Firefox grid rasters before the dpr 1 downscale #516
• fix: rasterize Firefox exports below the layout grid at the grid (#516) 817390e
• fix: keep one-line boxes from wrapping in the capture (#516) 575537e
• fix: capture text at its inflated size in Firefox for Android (#516) 5213172
• fix: size form control replacement SVGs with CSS under layout zoom (#516) 2d6d41d
• fix: resolve var() in SVG gradient stops (#515) b13ed28
• fix: emit the placeholder rule only when a placeholder was cloned eb26e15
• fix: keep placeholder color CSS off void inputs (#512) #514
• fix(capture): drop xmlns attributes set through setAttribute (#511) #513
• fix: read transform-origin on transformed pseudo-elements (#509) 39ff290

• docs: update plugin capabilities 9c0b8a3
• docs: home page from the design handoff e88be16
• docs: Labs overview, Showcase, Made with and Plugins join the 3-pane template 59046e9
• docs: move Docs, How-to, Guides, Compare, Blog and Labs pages to the 3-pane template f0dbc79
• docs: 3-pane Capabilities and Ecosystem pages from the design handoff d8b6688
• test: stop the network gate from skipping demos on a fast link, rerun what it skips 96fc884
• test: serve the d15 image from a local second origin 083cbd9
• test: restore imageSmoothingQuality only where the engine has it #516

• @jamalkamaladdin made their first contribution in https://github.com/zumerlab/snapdom/pull/513
• @00200200 made their first contribution in https://github.com/zumerlab/snapdom/pull/514

Full Changelog: https://github.com/zumerlab/snapdom/compare/v3.2.0...v3.3.0

• Unify bundle analyzer delta colors: #99607

Huge thanks to @wbinnssmith for helping!

The 10.11 release improves styling, raster data and OGC service support, and makes the library leaner to load. The highlights are

• Canvas styles now evaluate the color and array operators, and interpolate mixes colors in sRGB on both the Canvas and WebGL renderers; a new interpolate-hcl operator keeps the perceptual gradient
• ol/source/Raster gains basic data tile support, and the GeoZarr source can visualize generic n-D datacubes and accepts storeOptions for headers and credentials
• WMTS sources no longer derive their extent from the tile matrices, so layers that cover a wider area at low zoom levels are no longer cut off
• Tiles that the current view no longer needs are dropped from the queue, and the WebGL text overlay worker is loaded on demand
• The VectorImageLayer gets crisp rendering on rotated views, with rotated text and point symbols
• New wrapX option for getPixelFromCoordinate and getCoordinateFromPixel, and projection options for the WKT format
• Fixes for RTL text along lines, nested WFS 2.0 feature collections, empty GeoJSON coordinate arrays, and MouseWheelZoom target cleanup

Previously, a GeoJSON geometry with an empty coordinates array (e.g. {"type": "Point", "coordinates": []}) produced a geometry with an empty coordinates array. We have now changed this to match the GeoJSON spec's recommendation to treat such geometries (except GeometryCollection) as null geometries. This change should not affect application code, unless it had special handling for geometries with empty coordinates arrays.

The ['interpolate', ...] operator interpolated colors in the Hue-Chroma-Luminance space on the Canvas renderer, but component-wise in sRGB on the WebGL renderer. The same style produced different gradients depending on which renderer drew it, and neither behaviour was documented. Both now interpolate in sRGB.

Gradients built with interpolate over colors will look slightly different on the Canvas renderer. To keep the previous appearance, use the new interpolate-hcl operator:

// Before
const style = {
  'fill-color': ['interpolate', ['linear'], ['get', 'value'], 0, 'red', 1, 'green'],
};

// After - to keep the perceptual gradient
const style = {
  'fill-color': ['interpolate-hcl', ['linear'], ['get', 'value'], 0, 'red', 1, 'green'],
};

interpolate-hcl is only supported by the Canvas renderer for now.

With the ['interpolate', ...] operator, channels now keep their fractional part, so operations applied on top of an interpolated color are more accurate. Code reading back a color from an evaluated style may now see a fractional channel.

optionsFromCapabilities now only uses an advertised BoundingBox as the tile grid's extent, and tileGrid.getExtent() returns null when none is advertised. Tile requests are limited by the advertised tile matrix sizes and TileMatrixSetLimits instead, so layers that cover a wider area at low zoom levels than at high ones are no longer cut off.

The world is now wrapped when the first tile matrix spans exactly the width of the projection's extent, instead of when the layer's WGS84BoundingBox covers the whole world. Sources that cover only part of the world on a world spanning tile matrix set - e.g. a national basemap on GoogleMapsCompatible - are now configured with the wrapX option set to true. If that's undesired, wrapX needs to be overridden to false.

// Before
new WMTS(optionsFromCapabilities(capabilities, {layer: 'my-layer'}));

// After - to keep the layer in a single world copy
new WMTS({
  ...optionsFromCapabilities(capabilities, {layer: 'my-layer'}),
  wrapX: false,
});

The Layer's WGS84BoundingBox is no longer used, because the WMTS specification allows it to be approximate.

See below for a complete list of features and fixes.

• Replace broken example source with working one (by @ahocevar in https://github.com/openlayers/openlayers/pull/17606)
• Add projection options to WKT format (by @zarathustracode in https://github.com/openlayers/openlayers/pull/17646)
• Use a north arrow in the custom controls example (by @Egge-Jan in https://github.com/openlayers/openlayers/pull/17650)
• Load verbatim examples as ES modules (by @openlayers in https://github.com/openlayers/openlayers/pull/17654)
• Add "station-model-symbology" to 3rd party plugins (by @balladaniel in https://github.com/openlayers/openlayers/pull/17639)
• Fix MouseWheelZoom target cleanup (by @TayfurYldz in https://github.com/openlayers/openlayers/pull/17640)
• Add rotateContent option to VectorImageLayer (by @siznjk in https://github.com/openlayers/openlayers/pull/17616)
• Fix #17635: getTileRangeForTileCoordAndZ and add test (by @richard-ling in https://github.com/openlayers/openlayers/pull/17636)
• Add basic data tile support to ol/source/Raster (by @ahocevar in https://github.com/openlayers/openlayers/pull/17631)
• Fix fullscreen control icon on mobile (by @chiimyen in https://github.com/openlayers/openlayers/pull/17629)
• Upload the instance attributes buffer again when the points layer helper is recreated (by @globus243 in https://github.com/openlayers/openlayers/pull/17628)
• Allow example API keys to be overridden in development (by @tschaub in https://github.com/openlayers/openlayers/pull/17626)
• fix: add fetchSessionToken option to Google (by @gioboa in https://github.com/openlayers/openlayers/pull/17624)
• Respect the stride parameter in deflateCoordinate (by @ethanstoner in https://github.com/openlayers/openlayers/pull/17614)
• Handle empty geojson coordinate arrays correctly (by @ahocevar in https://github.com/openlayers/openlayers/pull/17615)
• fix: read nested WFS 2.0 FeatureCollections (by @gioboa in https://github.com/openlayers/openlayers/pull/17622)
• fix: fix RTL text along lines (by @gioboa in https://github.com/openlayers/openlayers/pull/17621)
• Align text to visible part of line only when textAlign is undefined (by @ahocevar in https://github.com/openlayers/openlayers/pull/17619)
• Evaluate the color and array operators in canvas styles (by @ahocevar in https://github.com/openlayers/openlayers/pull/17611)
• Interpolate colors in sRGB, and add interpolate-hcl (by @ahocevar in https://github.com/openlayers/openlayers/pull/17610)
• Load the text overlay worker on demand (by @ahocevar in https://github.com/openlayers/openlayers/pull/17608)
• Add wrapX option to getPixelFromCoordinate and getCoordinateFromPixel (by @fredj in https://github.com/openlayers/openlayers/pull/17514)
• Support visualization of generic n-D GeoZarr datacubes (by @m-mohr in https://github.com/openlayers/openlayers/pull/17602)
• Fix deploy preview (by @ahocevar in https://github.com/openlayers/openlayers/pull/17603)
• Accept any thenable where a Promise was required (by @matousekm in https://github.com/openlayers/openlayers/pull/17600)
• Add storeOptions (headers, credentials) to GeoZarr source (by @m-mohr in https://github.com/openlayers/openlayers/pull/17601)
• Replace sinon with vi in the tests (by @hyeonjun-L in https://github.com/openlayers/openlayers/pull/17594)
• Drop queued tiles that the current view no longer needs (by @xvodddwannaG in https://github.com/openlayers/openlayers/pull/17595)
• fix: wmts options from capabilities matrixSet over projection lookup when configured (by @lubojr in https://github.com/openlayers/openlayers/pull/17593)
• Do not derive the WMTS extent from tile limits (by @xvodddwannaG in https://github.com/openlayers/openlayers/pull/17591)
• Enable strict mode for tsc (by @tschaub in https://github.com/openlayers/openlayers/pull/17588)
• Reworked worker handling in examples (by @tschaub in https://github.com/openlayers/openlayers/pull/17584)
• Include node version in .nvmrc (by @tschaub in https://github.com/openlayers/openlayers/pull/17569)
• Use fes:ResourceId in WFS 2.0.0 transaction filters (by @sobol-sudo in https://github.com/openlayers/openlayers/pull/17583)
• Updates for the 10.10.0 release (by @openlayers in https://github.com/openlayers/openlayers/pull/17582)

• xls: Read BIFF5/7 workbooks (Excel 5.0/95)  -  by @dmythro in https://github.com/productdevbook/hucre/issues/572 (8ad01)
• xlsx: Support autoFilter and conditionalRules in stream writer  -  by @ryuhzk in https://github.com/productdevbook/hucre/issues/571 (c9ed7)

• Bound XLSX allocation and number-format work  -  by @productdevbook in https://github.com/productdevbook/hucre/issues/577 (680e3)
• xls,xlsb: A FORMAT record redefining a built-in id wins  -  by @dmythro in https://github.com/productdevbook/hucre/issues/568 and https://github.com/productdevbook/hucre/issues/569 (de00f)

• xlsx: Spin the Agile password hash synchronously  -  by @barathrajd and Claude Opus 5.5 in https://github.com/productdevbook/hucre/issues/575 (82916)

app.mount() is now available as the Mount Middleware, hono/mount. It is just a handler, so you register it with app.all():

import { Router as IttyRouter } from 'itty-router'
import { Hono } from 'hono'
import { mount } from 'hono/mount'

const ittyRouter = IttyRouter()
ittyRouter.get('/hello', () => new Response('Hello from itty-router'))

const app = new Hono()
app.all('/itty-router/*', mount(ittyRouter.handle))

app.mount() still works in v4 but is deprecated and will be removed in v5. Migrating is a one-line change:

- app.mount('/itty-router', ittyRouter.handle)
+ app.all('/itty-router/*', mount(ittyRouter.handle))

• test(client): simulate network error for undefined route in parseResponse test in https://github.com/honojs/hono/pull/5439
• docs(request): fix jsdoc comments for some getters in https://github.com/honojs/hono/pull/5445
• fix(jsx): allow JSXNode function component results in https://github.com/honojs/hono/pull/5476
• feat(mount): introduce Mount Middleware and deprecate app.mount in https://github.com/honojs/hono/pull/5221

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

• Followup from #99249 remove some redundant tests and enable missing assertions all the time: #99605
• Simplify turbo-tasks-backend guards and execution contexts: #99599
• Add allocation and memory data to the trace-server MCP protocol: #98546
• turbo-tasks-backend: check access in track_modification and only track Data on serialization invalidation: #99581
• Fix CI break caused by #98932: #99621
• Fix: Unnecessary Suspense fallback triggered by URL update: #99612
• Don't suspend client params on shallow URL updates: #99611
• Add React Compiler memoization preservation option: #98589

Huge thanks to @lukesandberg, @sokra, @acdlite, and @wbinnssmith for helping!

Release 2026-10-03 20:18

• angular: add theme option in devtools (#11786) (afdf6173e) by @benjavicente

• @tanstack/angular-query@5.0.0-rc.1
• @tanstack/angular-query-devtools@5.0.0-rc.1
• @tanstack/angular-query-persist-client@5.0.0-rc.1