fix(deps): update all non-major dependencies by renovate[bot] · Pull Request #145 · RevoTale/cms

renovate · 2026-10-04T01:55:47Z

Note

This PR body was truncated due to platform limits.

This PR contains the following updates:

Package	Change	Type	Update	Pending
@apollo/client (source)	`4.2.12` → `4.3.5`	dependencies	minor	`4.3.6`
@biomejs/biome (source)	`2.5.10` → `2.6.3`	devDependencies	minor	`2.6.4`
@graphql-codegen/add (source)	`^7.1.0` → `^7.1.0`	devDependencies	patch
@graphql-codegen/cli (source)	`7.3.1` → `7.4.6`	devDependencies	minor
@graphql-codegen/client-preset (source)	`6.1.3` → `6.2.3`	devDependencies	minor
@graphql-codegen/schema-ast (source)	`^6.1.0` → `^6.1.0`	devDependencies	patch
@hookform/resolvers (source)	`5.9.1` → `5.9.2`	dependencies	patch
@lexical/code (source)	`^0.49.0` → `^0.52.0`	dependencies	minor	`0.53.0`
@lexical/link (source)	`^0.49.0` → `^0.52.0`	dependencies	minor	`0.53.0`
@lexical/list (source)	`^0.49.0` → `^0.52.0`	dependencies	minor	`0.53.0`
@lexical/markdown (source)	`^0.49.0` → `^0.52.0`	dependencies	minor	`0.53.0`
@lexical/react (source)	`^0.49.0` → `^0.52.0`	dependencies	minor	`0.53.0`
@lexical/rich-text (source)	`^0.49.0` → `^0.52.0`	dependencies	minor	`0.53.0`
@lexical/table (source)	`^0.49.0` → `^0.52.0`	dependencies	minor	`0.53.0`
@mdxeditor/editor (source)	`4.2.1` → `4.3.4`	dependencies	minor	`4.5.0` (+1)
@next/bundle-analyzer (source)	`16.3.3` → `16.4.3`	dependencies	minor	`16.4.5` (+1)
@payloadcms/db-postgres (source)	`3.88.0` → `3.92.1`	dependencies	minor
@payloadcms/graphql (source)	`3.88.0` → `3.92.1`	dependencies	minor
@payloadcms/next (source)	`3.88.0` → `3.92.1`	dependencies	minor
@payloadcms/plugin-cloud-storage (source)	`3.88.0` → `3.92.1`	dependencies	minor
@payloadcms/plugin-search (source)	`3.88.0` → `3.92.1`	dependencies	minor
@payloadcms/plugin-seo (source)	`3.88.0` → `3.92.1`	dependencies	minor
@payloadcms/ui (source)	`3.88.0` → `3.92.1`	dependencies	minor
@radix-ui/react-avatar (source)	`1.2.6` → `1.3.1`	dependencies	minor
@radix-ui/react-checkbox (source)	`1.3.11` → `1.4.1`	dependencies	minor
@radix-ui/react-dialog (source)	`1.1.23` → `1.3.1`	dependencies	minor
@radix-ui/react-hover-card (source)	`1.1.23` → `1.2.1`	dependencies	minor
@radix-ui/react-label (source)	`2.1.15` → `2.1.17`	dependencies	patch
@radix-ui/react-progress (source)	`1.1.16` → `1.2.1`	dependencies	minor
@radix-ui/react-scroll-area (source)	`1.2.18` → `1.4.0`	dependencies	minor
@radix-ui/react-select (source)	`2.3.7` → `2.4.1`	dependencies	minor
@radix-ui/react-separator (source)	`1.1.15` → `1.2.0`	dependencies	minor
@radix-ui/react-slot (source)	`1.3.3` → `1.5.0`	dependencies	minor
@radix-ui/react-switch (source)	`1.3.7` → `1.4.1`	dependencies	minor
@radix-ui/react-tooltip (source)	`1.2.16` → `1.4.1`	dependencies	minor
@swc-contrib/plugin-graphql-codegen-client-preset (source)	`^0.32.0` → `^0.36.0`	dependencies	minor	`0.37.1` (+1)
@types/node (source)	`26.3.0` → `26.6.5`	devDependencies	minor	`26.6.6`
@types/react (source)	`^19.2.18` → `^19.3.0`	devDependencies	minor
@types/react-dom (source)	`^19.2.5` → `^19.3.0`	devDependencies	minor
ghcr.io/revotale/infrastructure-imgproxy	`0.0.20` → `0.0.21`		patch
jose	`6.2.10` → `6.2.13`	dependencies	patch	`6.2.15` (+1)
lexical (source)	`^0.49.0` → `^0.52.0`	dependencies	minor	`0.53.0`
lucide-react (source)	`1.34.0` → `1.62.0`	dependencies	minor	`1.67.0` (+4)
next-intl (source)	`4.13.7` → `4.14.9`	dependencies	minor
openai	`7.5.0` → `7.45.1`	dependencies	minor	`7.50.0` (+4)
pnpm (source)	`11.23.0` → `11.28.9`	packageManager	minor	`11.28.10`
pnpm (source)	`11.23.0` → `11.28.9`	engines	minor	`11.28.10`
postcss (source)	`^8.5.26` → `^8.5.26`	devDependencies	patch
react (source)	`19.2.8` → `19.3.1`	dependencies	minor
react-dom (source)	`19.2.8` → `19.3.1`	dependencies	minor
react-hook-form (source)	`7.86.0` → `7.91.0`	dependencies	minor
schema-dts (source)	`2.0.0` → `2.1.0`	dependencies	minor
tailwind-merge (source)	`3.6.0` → `3.7.0`	dependencies	minor
unist-util-visit	`5.1.0` → `5.2.0`	dependencies	minor
use-intl (source)	`4.13.7` → `4.14.9`	dependencies	minor

Release Notes

apollographql/apollo-client (@apollo/client)

`v4.3.5`

Compare Source

Patch Changes

#13498 04b12e5 Thanks @jerelmiller! - Fix an issue where custom scalar values that are not JSON-serializable caused errors. These values are properly serialized when used as input for variables or when used as a key field value so that cache writes and calls to cache.identify succeed.
#13500 a23ea85 Thanks @jerelmiller! - Require the variables option in useFragment when the fragment has required variables. This matches the behavior of useSuspenseFragment and the query hooks.
#13501 303d80f Thanks @kgssystem! - Parse custom scalar fields in subscription results when using the no-cache fetch policy.

`v4.3.4`

Compare Source

Patch Changes

#13497 41d604c Thanks @jerelmiller! - Fix an issue where a list field selected more than once with different selection sets lost the fields that only one of the selections included while a @defer boundary elsewhere in the query was still pending when using the GraphQL17Alpha9Handler. The results of all selections of the list field are now merged.
#13457 22746bb Thanks @phryneas! - Fixed a bug where streamFieldInfo might not have been passed into custom merge functions for
@stream directives that had an aliased field in the path.
#13457 22746bb Thanks @phryneas! - Fix Missing field errors being logged when writing @defer results where a parent field is selected both inside and outside of a deferred fragment. Fields whose @defer boundary has not been delivered from the network are no longer reported as missing.
#13453 9bb3a41 Thanks @wassim-k! - Unregister the watch when an immediate cache.watch broadcast throws. Previously the watch was added to the cache before its first read, and a read that threw left the watch registered while the caller never received the unsubscribe function, so it could not be removed and every later broadcast ran into the same failing read.
#13457 22746bb Thanks @phryneas! - Defer20220824Handler: fix a situation where dataState would show up as completed with incremental errors instead of staying streaming.

`v4.3.3`

Compare Source

Patch Changes

#13479 0ab2579 Thanks @phryneas! - Fix a memory leak in isDeferredFragment/isStreamField

`v4.3.2`

Compare Source

Patch Changes

#13467 7786771 Thanks @SSpirate11! - Fix an unhandled AbortError promise rejection that occurred when unsubscribing from a multipart HTTP subscription.

`v4.3.1`

Compare Source

Patch Changes

#13464 37f700e Thanks @jerelmiller! - Fix an issue where useLazyQuery did not rerender with new variables until the network request had completed when calling execute with new variables while a request was already in-flight.

`v4.3.0`

Compare Source

Minor Changes

#13447 24133fe Thanks @jerelmiller! - Field policies and inputObjects can now tell the cache whether a field is a list of scalars or a scalar whose value is an array. Previously all arrays were iterated and only the inner type was provided to the scalar parse/serialize functions.

This required some breaking changes from previous prerelease versions:

The field policy scalar option and inputObjects type string now use GraphQL list syntax to mark a field as a list of scalars
The abstract cache.getScalarForField is now cache.getScalarTypeForField and is expected to return the string representing the scalar type rather than the Scalar instance

new InMemoryCache({
  scalars: {
    DateTime: new Scalar(/*...*/),
  },
  inputObjects: {
    EventFilter: {
      fields: {
        // Previously only the scalar type was provided
        datesBefore: "DateTime",

        // List syntax now required
        datesAfter: "[DateTime]",
        dates2d: "[[DateTime]]",
      },
    },
  },
  typePolicies: {
    Event: {
      fields: {
        // Previously only the scalar type was provided
        datesBefore: {
          scalar: "DateTime",
        },

        // List syntax now required
        datesAfter: {
          scalar: "[DateTime]",
        },
        dates2d: {
          scalar: "[[DateTime]]",
        },
      },
    },
  },
});

Now it's possible to handle scalars that are represented by arrays:

const dateTimeRangeScalar = new Scalar<
  [string, string],
  { start: Date; end: Date }
>({
  parse: ([start, end]) => ({
    start: new Date(start),
    end: new Date(end),
  }),
  serialize: (range) => [range.start.toISOString(), range.end.toISOString()],
  is: (value) => !Array.isArray(value),
});

const cache = new InMemoryCache({
  scalars: {
    DateTimeRange: dateTimeRangeScalar,
  },
  typePolicies: {
    Event: {
      fields: {
        range: {
          scalar: "DateTimeRange",
        },
      },
    },
  },
});

const query = gql`
  query {
    event {
      range
    }
  }
`;

cache.writeQuery({
  query,
  data: {
    event: {
      __typename: "Event",
      // Server returns DateTimeRange as a JSON array
      range: ["2024-01-01T00:00:00Z", "2024-06-01T00:00:00Z"],
    },
  },
});

const { data } = useQuery(query);
// => { event: { __typename: "Event", range: { start: Date, end: Date } } }

#13324 0abd8de Thanks @jerelmiller! - Fix the accuracy of dataState in complex incremental streaming scenarios, especially when combined with returnPartialData: true.

Prior to this change, all intermediate chunks used for both @defer and @stream directives returned a dataState of streaming, regardless of whether the actual data shape fit the definition of the streaming data state. The streaming data state represents an incomplete incremental response where the only holes in the data occur at @defer boundaries.

Let's use the following example of where the previous dataState fell down when combined with returnPartialData.
```
query GreetingQuery {
  greeting {
    message
    ... @defer {
      recipient {
        name
        email
      }
    }
  }
}
```
1. Scenario 1: partial data inside a @defer boundary written to the cache
Let's say the cache contained the following partial data:
```
{
  greeting: {
    __typename: "Greeting",
    recipient: {
      __typename: "Person",
      name: "John Doe",
    },
  },
};
```
After the first chunk arrives from the server, the data looks like the following:
```
{
  greeting: {
    __typename: "Greeting",
    message: "Hello, John",
    recipient: {
      __typename: "Person",
      name: "John Doe",
    },
  },
};
```
This data is not complete because recipient.email is missing. This data is also not streaming because the data requirements in the @defer boundary are partially fulfilled due to the existence of recipient. This could lead to runtime crashes on recipient.email if you use the existence of recipient to detect whether data in the @defer boundary has streamed in or not. This change now accurately reports this as partial to ensure the field is marked as a partial field in recipient.
1. Scenario 2: partial data written to the cache that fulfills the data requirements of the @defer boundary
Let's say the cache contained the following partial data:
```
{
  greeting: {
    __typename: "Greeting",
    recipient: {
      __typename: "Person",
      name: "John Doe",
      email: "john@example.com",
    },
  },
};
```
After the first chunk arrives from the server, the data looks like the following:
```
{
  greeting: {
    __typename: "Greeting",
    message: "Hello, John",
    recipient: {
      __typename: "Person",
      name: "John Doe",
      email: "john@example.com",
    },
  },
};
```
In this case, the combination of the first chunk and the partial data in the cache now fulfills the data requirements of the query. Even though the server is still streaming data (NetworkStatus.streaming), we can report this as dataState: "complete" since it is safe to access data on all fields.

This change also means @stream queries by definition fulfill the data requirements of the query after the first chunk arrives since @stream operates on lists and contains no data holes. @stream queries now accurately report dataState as complete or partial, depending on whether the list mixes partial data with streamed list items.

As a result of this change, some cases where you'd previously see dataState reported as "streaming" are now reported as partial or complete.

If you use dataState to determine whether an incremental request is still in-flight, please use networkStatus instead to check for NetworkStatus.streaming. dataState is type narrowing feature and not intended to report the network status.

#13274 7b10078 Thanks @jerelmiller! - Adds Scalar.fromGraphQLScalarType helper to create a Scalar instance from an existing graphql.js GraphQLScalarType.

import { GraphQLScalarType } from "graphql";
import { Scalar } from "@apollo/client";

const dateTimeScalarType = new GraphQLScalarType<Date, string>({
  // ...
});

const dateTimeScalar = Scalar.fromGraphQLScalarType(dateTimeScalarType, {
  is: (value) => value instanceof Date,
});

#13421 d6197a4 Thanks @jerelmiller! - The minimum supported TypeScript version is now 5.9.x.

#13270 d080f11 Thanks @jerelmiller! - Adds the plumbing and types implementation for declaring custom scalars and configuring custom scalars in InMemoryCache.

You can declare custom scalar types with declaration merging on the ApolloCache.Scalars interface:

// apollo.d.ts
import "@apollo/client";

declare module "@apollo/client" {
  namespace ApolloCache {
    interface Scalars {
      Date: { serialized: string; parsed: Date };
    }
  }
}

This enables the scalars option in InMemoryCache:

import { Scalar } from "@apollo/client";

const cache = new InMemoryCache({
  scalars: {
    Date: new Scalar({
      parse: (dateString) => new Date(dateString),
      serialize: (date) => date.toISOString(),
      is: (value) => value instanceof Date,
    }),
  },
});

#13250 bad7035 Thanks @jerelmiller! - Add the ability to define the cache type for the client. client.cache currently returns ApolloCache as the cache type regardless of what cache you've provided to ApolloClient.

Declare the cache type using the cache property in the TypeOverrides interface to set the cache implementation used for the client.
```
// apollo.d.ts
import type { InMemoryCache } from "@apollo/client";

declare module "@apollo/client" {
  export interface TypeOverrides {
    cache: InMemoryCache;
  }
}
```
Now anywhere cache is accessible, the type is the declared cache type:
```
client.cache;
//     ^? InMemoryCache

client.mutate({
  update: (cache) => {
    //     ^? InMemoryCache
  },
});
```
[!NOTE]
Setting a cache type enforces that cache type in the cache option for the ApolloClient constructor.
#13406 bd74ccb Thanks @jerelmiller! - Emit a development-only warning when a feud is detected between queries that overwrite each other's data. This should make it easier to detect when you need to select a key field or add a merge function to a field policy.
#13390 90e338c Thanks @jerelmiller! - Fix issue where sibling @defer fragments were pruned incorrectly when at least one of the @defer fragments wasn't delivered.

As a result of this change, a label argument is now added to all outgoing @defer directives when using the GraphQL17Alpha9Handler in order to disambiguate the @defer fragments from each other.
#13426 a9beaff Thanks @jerelmiller! - Version bump only to rc.
#13416 f2d5d5a Thanks @jerelmiller! - Add GraphQLCodegenIncremental type overrides that assemble GraphQL Codegen @defer operation types when dataState is "complete".
#13372 e4cde69 Thanks @jerelmiller! - Parse scalar fields for no-cache queries.

#13386 0be8fd8 Thanks @atharv-sys32! - Support skipToken with useSubscription to provide a more type-safe way to skip subscription execution with required variables.

import { skipToken, useSubscription } from "@apollo/client/react";

// Use `skipToken` in place of `skip: true` for better type safety
// for required variables
const { data } = useSubscription(
  SUBSCRIPTION,
  id ? { variables: { id } } : skipToken
);

#13337 2df711f Thanks @jcostello-atlassian! - Allow overriding the from input of useFragment, useSuspenseFragment, readFragment, writeFragment and related fragment APIs via a new FromOptionValue key on the TypeOverrides interface.

By default, from continues to accept StoreObject | Reference | FragmentType<TData> | string. Apps can now supply a stricter policy (for example, requiring __typename and disallowing nullish identifier values) without affecting StoreObject, cache.identify, cache.modify or optimistic writes.

// apollo.d.ts
import "@apollo/client";
import type { HKT, StoreValue } from "@apollo/client/utilities";

type StrictFrom<TData extends { __typename: string }> =
  | {
      // the `__typename` has to match the one of the fragment type
      __typename: TData["__typename"];
      // `& {}` forces values to be "defined" so an explicit `undefined`
      // (as well as `null`) is rejected.
      [key: string]: Exclude<StoreValue, null | undefined> & {};
    }
  | { __ref: string }
  | string
  | null;

interface StrictFromHKT extends HKT {
  arg1: { __typename: string }; // TData
  return: StrictFrom<this["arg1"]>;
}

declare module "@apollo/client" {
  export interface TypeOverrides {
    FromOptionValue: StrictFromHKT;
  }
}

#13405 f923ab4 Thanks @jerelmiller! - Field policy read and merge functions are now ignored when the field policy configures the scalar option. If a read or merge function is provided alongside scalar, a development-only warning is emitted.
#13393 434d25f Thanks @jerelmiller! - Change when @defer fragments and @stream fields are pruned for cache-first and cache-and-network fetch policies to better match the network when the initial value contained a partial result:
- cache-first: prune undelivered @defer fragments or @stream items when the result is fetched from the network due to a partial result
- cache-and-network: prune undelivered @defer fragments or @stream items if the initial cache value was partial. If the first value emitted from the cache is complete, the results will not be pruned.
This makes the emitted results more predictable by following what the network has delivered and avoids some ambiguity in other edge cases.

For example, with a cache-first fetch policy where all @defer fields are written to the cache, but a non-deferred field is partial, the values emitted from the client previously looked like the following:
```
query {
  user {
    id
    name
    ... @defer {
      email
    }
  }
}
```
```
// data written to the cache is missing name
{ user: { id: 1, email: "user.cache@example.com" }}

// 1. empty because the result is partial
{ data: undefined, dataState: "empty", ... }
// 2. returns all data because the cache contains a value for email
{ data: { user: 1, name: "User", email: "user.cache@example.com" }, dataState: "complete" }
// 3. email updated from the server
{ data: { user: 1, name: "User", email: "user.network@example.com" }, dataState: "complete" }
```
Here the result is confusing because the initial value returned from the query was undefined, yet a complete result was returned after the initial chunk from the network returned (which did not contain email).

The cache values are now pruned if the network hasn't delivered them yet:
```
// 1. empty because the result is partial
{ data: undefined, dataState: "empty" }
// 2. email hasn't been delivered by the network so it gets pruned
{ data: { user: 1, name: "User" }, dataState: "streaming" }
// 3. full result returned after the network streams the email field
{ data: { user: 1, name: "User", email: "user.network@example.com" }, dataState: "complete" }
```
This is especially helpful in situations where @defer boundaries that are never delivered due to errors prevent an awkward situation where the client would otherwise have to choose whether to serve the stale cache result from the cache, or prune the undelivered fragment on the final chunk.

#13270 6031987 Thanks @jerelmiller! - Adds a scalar option to InMemoryCache field policies that tells the cache which scalar to use when parsing or serializing the field value.

import { Scalar } from "@apollo/client";

new InMemoryCache({
  scalars: {
    DateTime: new Scalar({
      parse: (dateString) => new Date(dateString),
      serialize: (date) => date.toISOString(),
    }),
  },
  typePolicies: {
    Event: {
      fields: {
        startTime: {
          // Parse this field using the DateTime scalar
          scalar: "DateTime",
        },
      },
    },
  },
});

This scalar definition is now used to properly parse or serialize the field value for cache reads and writes as well as cache.extract() and cache.restore().

#13273 0886de1 Thanks @jerelmiller! - Automatically serialize variables that include custom scalar values. This includes cache reads and writes as well as requests to the network.

For more complex input objects, a new inputObjects option is available to InMemoryCache that specifies where nested scalar fields are found.

const cache = new InMemoryCache({
  scalars: {
    DateTime: new Scalar({
      parse: (value) => new Date(value),
      serialize: (value) => value.toISOString(),
      is: (value) => value instanceof Date,
    }),
  },
  inputObjects: {
    EventFilter: {
      fields: {
        date: "DateTime",
      },
    },
  },
});

const client = new ApolloClient({ cache, link });

await client.query({
  query: gql`
    query Event($filter: EventFilter!) {
      event(filter: $filter) {
        name
      }
    }
  `,
  variables: {
    filter: {
      date: new Date("2026-01-01T00:00:00.000Z"),
    },
  },
});

// The link receives:
// { filter: { date: "2026-01-01T00:00:00.000Z" } }

#13424 d2bca2e Thanks @jerelmiller! - Remove the custom NoInfer type utility in favor of the native NoInfer introduced in TypeScript 5.4.
#13270 d080f11 Thanks @jerelmiller! - Adds the getScalar abstract method to ApolloCache that cache subclasses override to provide scalar behavior to Apollo Client. Defaults to unconditionally return undefined if not specified.
#13406 bd74ccb Thanks @jerelmiller! - Fixes an issue where cache feuds between queries selecting incompatible non-normalized data could return untransformed network values.

Apollo Client now always writes network results to the cache before delivering them, ensuring custom scalars and field read functions are applied. To prevent repeated refetches when competing queries repeatedly make each other's cache results incomplete, Apollo Client stops automatically refetching a query after it sees the same incomplete result again.

This may add one network request in these cache-feud scenarios.
#13275 263f987 Thanks @jerelmiller! - Make sure scalars are correctly returned for mutations and subscriptions.

[!NOTE]
This change affects cache reads after mutations as mutations now reread from the cache after each execution that writes a result to the cache. Previously mutations only reread from the cache when an update function was provided. This can have an effect on the result if you have union or interface types in the mutation but forget to include possibleTypes which might return a result that doesn't include the interface/union fields.

Patch Changes

#13408 7a5164d Thanks @jerelmiller! - Fix dataState to report "streaming" instead of "partial" when returnPartialData is true and the cache result is missing only @defer fields.
#13381 9c73762 Thanks @jerelmiller! - Fix an issue where a network-only query leaked partial cache data for @defer fragments that were not delivered by the network due to an error that bubbled to the @defer fragment boundary.
#13390 90e338c Thanks @jerelmiller! - Fix an issue where a sibling non-deferred fragment might be accidentally pruned when

[!IMPORTANT]
✂ PR body was truncated to here.

Configuration

📅 Schedule: (UTC)

Branch creation
- At any time (no schedule defined)
Automerge
- At any time (no schedule defined)

🚦 Automerge: Disabled by config. Please merge this manually once you are satisfied.

♻ Rebasing: Whenever PR becomes conflicted, or you tick the rebase/retry checkbox.

👻 Immortal: This PR will be recreated if closed unmerged. Get config help if that's undesired.

If you want to rebase/retry this PR, check this box

This PR was generated by Mend Renovate. View the repository job log.

renovate Bot force-pushed the renovate/all-minor-patch branch 17 times, most recently from d737614 to 265ad25 Compare October 11, 2026 01:06

renovate Bot force-pushed the renovate/all-minor-patch branch 13 times, most recently from 64f13bc to b4c02cb Compare October 16, 2026 05:14

renovate Bot force-pushed the renovate/all-minor-patch branch 15 times, most recently from 7777ed2 to 705b9a2 Compare October 27, 2026 18:26

renovate Bot force-pushed the renovate/all-minor-patch branch 13 times, most recently from a32f134 to 06ceb6b Compare November 3, 2026 10:51

fix(deps): update all non-major dependencies

43418f5

renovate Bot force-pushed the renovate/all-minor-patch branch from 06ceb6b to 43418f5 Compare November 4, 2026 03:03

Navigation Menu

Repository navigation

fix(deps): update all non-major dependencies - #145

fix(deps): update all non-major dependencies#145
renovate[bot] wants to merge 1 commit into
mainfrom
renovate/all-minor-patch

renovate Bot commented Oct 4, 2026 •

edited

Loading

Uh oh!

Reviewers

Uh oh!

Assignees

Labels

Projects

Milestone

Development

Uh oh!

0 participants

Conversation

renovate Bot commented Oct 4, 2026 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Release Notes

v4.3.5

Patch Changes

v4.3.4

Patch Changes

v4.3.3

Patch Changes

v4.3.2

Patch Changes

v4.3.1

Patch Changes

v4.3.0

Minor Changes

Patch Changes

Configuration

Uh oh!

Reviewers

Uh oh!

Assignees

Labels

Projects

Milestone

Development

Uh oh!

0 participants

renovate Bot commented Oct 4, 2026 •

edited

Loading

`v4.3.5`

`v4.3.4`

`v4.3.3`

`v4.3.2`

`v4.3.1`

`v4.3.0`