chore(deps): update all non-major dependencies #6

renovate · 2026-01-12T01:06:43Z

ℹ️ Note

This PR body was truncated due to platform limits.

This PR contains the following updates:

Package	Change	Age	Confidence
@biomejs/biome (source)	`^2.3.2` → `^2.3.11`
@effect/language-service	`^0.44.0` → `^0.71.0`
tsdown (source)	`^0.15.7` → `^0.19.0`

Release Notes

biomejs/biome (@biomejs/biome)

`v2.3.11`

Compare Source

Patch Changes

#8583 83be210 Thanks @dyc3! - Added the new nursery rule useVueValidTemplateRoot.

This rule validates only root-level <template> elements in Vue single-file components. If the <template> has a src attribute, it must be empty. Otherwise, it must contain content.

Invalid examples:
```
<template src="./foo.html">content</template>
```
```
<template></template>
```
Valid examples:
```
<template>content</template>
```
```
<template src="./foo.html"></template>
```
#8586 df8fe06 Thanks @dyc3! - Added a new nursery rule useVueConsistentVBindStyle. Enforces consistent v-bind style (:prop shorthand vs v-bind:prop longhand). Default prefers shorthand; configurable via rule options.
#8587 9a8c98d Thanks @dyc3! - Added the rule useVueVForKey, which enforces that any element using v-for also specifies a key.

Invalid
```
<li v-for="item in items">{{ item }}</li>
```
Valid
```
<li v-for="item in items" :key="item.id">{{ item }}</li>
```
#8586 df8fe06 Thanks @dyc3! - Added a new nursery rule useVueConsistentVOnStyle. Enforces consistent v-on style (@event shorthand vs v-on:event longhand). Default prefers shorthand; configurable via rule options.
#8583 83be210 Thanks @dyc3! - Added the new nursery rule useVueValidVOnce. Enforces that usages of the v-once directive in Vue.js SFC are valid.
```

<div v-once />


<div v-once:aaa />
<div v-once.bbb />
<div v-once="ccc" />
```
#8498 d80fa41 Thanks @tt-a1i! - Fixed #8494. Extended noUndeclaredEnvVars to support bracket notation (process.env["VAR"], import.meta.env["VAR"]), Bun runtime (Bun.env.VAR, Bun.env["VAR"]), and Deno runtime (Deno.env.get("VAR")).
#8509 574a909 Thanks @ematipico! - Added support for parsing and formatting the Svelte {#await} syntax, when html.experimentalFullSupportEnabled is set to true.
```
-{#await promise  then name }
+{#await promise then name}

-{:catch    name}
+{:catch name}

{/await}
```
#8316 d64e92d Thanks @washbin! - Added the new nursery rule noMultiAssign. This rule helps to prevent multiple chained assignments.

For example, the following code triggers because there are two assignment expressions in the same statement.
```
const a = (b = 0);
```
#8592 a5f59cd Thanks @Netail! - Added the nursery rule useUniqueInputFieldNames. Require fields within an input object to be unique.

Invalid:
```
query A($x: Int, $x: Int) {
  field
}
```
#8524 17a6156 Thanks @JacquesLeupin! - Fixed #8488: Relative plugin paths are now resolved from the configuration file directory, including when configurations are merged (e.g. extends: "//").
#8655 3260ec9 Thanks @JacquesLeupin! - Fixed #8636: Biome's CSS formatter now breaks comma-separated declaration values at top-level commas when wrapping.

#8537 cc3e851 Thanks @dibashthapa! - Fixed #8491: Resolved false positive errors for safe boolean expressions. There are still pending fixes. Head to #8491 (comment) for more details

This new change will check for safe boolean expressions in variable declarations.

For example,

Valid:

let isOne = 1;
let isPositiveNumber = number > 0;

return (
  <div>
    {" "}
    {isOne && "One"} {isPositiveNumber && "Is positive"}
  </div>
);

Invalid:

let emptyStr = "";
let isZero = 0;

return (
  <div>
    {emptyStr && "Empty String"} {isZero && "Number is zero"}{" "}
  </div>
);

#8511 16a9036 Thanks @ematipico! - Improved the diagnostics of the rules useSortedClasses and noUnnecessaryConditions. The diagnostics now state that these rules are a work in progress and link to the relevant GitHub issue.
#8521 a704be9 Thanks @ToBinio! - Added the nursery rule useVueConsistentDefinePropsDeclaration, which enforces consistent defineProps declaration style.

Invalid

<script setup lang="ts">
const props = defineProps({
  kind: { type: String },
});
</script>

Valid

<script setup lang="ts">
const props = defineProps<{
  kind: string;
}>();
</script>

#8595 7c85bf0 Thanks @dyc3! - Fixed #8584: The HTML formatter will preserve whitespace after some elements and embedded expressions, which more closely aligns with Prettier's behavior.
```
- <h1>Hello, {framework}and Svelte!</h1>
+ <h1>Hello, {framework} and Svelte!</h1>
```
#8598 5e85d43 Thanks @Netail! - Added the nursery rule useUniqueFieldDefinitionNames. Require all fields of a type to be unique.

Invalid:
```
type SomeObject {
  foo: String
  foo: String
}
```
#8495 b573d14 Thanks @taga3s! - Fixed #8405: noMisusedPromises now emits warnings/errors when a function returns union types such as T | Promise<T> which is used in conditionals.
```
const a = (): boolean | Promise<boolean> => Promise.resolve(true);
if (a()) {
} // Now correctly flagged
```
#8632 0be7d12 Thanks @Bertie690! - The documentation & rule sources for lint/complexity/noBannedTypes have been updated to fix a few oversights.

In addition to some general typo fixes:
- The rule now recommends Record<keyof any, never> instead of Record<string, never> (the latter of which incorrectly allows symbol-keyed properties).
- The rule mentions an alternate method to enforce object emptiness involving unique symbol-based guards used by type-fest and many other packages:
```
declare const mySym: unique symbol;

// Since this type's only property is an unexported `unique symbol`, nothing that imports it can specify any properties directly
// (as far as excess property checks go)
export type EmptyObject = { [mySym]?: never };
export type IsEmptyObject<T> = T extends EmptyObject ? true : false;
```
The rule's listed sources have been updated as well to reflect the original source rule (ban-types) having been split into 3 separate rules circa April 2024.
#8580 a3a1ad2 Thanks @taga3s! - Added the nursery rule noBeforeInteractiveScriptOutsideDocument to the Next.js domain.
This rule prevents usage of next/script's beforeInteractive strategy outside of pages/_document.js.
#8493 5fc24f4 Thanks @ematipico! - Added support for parsing and formatting the Svelte {#each} syntax, when html.experimentalFullSupportEnabled is set to true.
```
- {#each items   as item  }
+ {#each items as item}

{/each}
```
#8546 0196c0e Thanks @Zaczero! - Hardened union static-member type flattening in edge cases (e.g. unions containing unknown or inferred expression types). This keeps inference conservative and avoids unstable type growth in node = node.parent-style loops.
#8569 1022c76 Thanks @ematipico! - Fixed an issue where the Biome HTML parser would emit a parse error when certain keywords are inside the text of HTML tags.
#8606 f50723b Thanks @dyc3! - Fixed #8563: fixed a bounds check on bogus regex literals that caused panics when doing type inference
#7410 ab9af9a Thanks @sgarcialaguna! - Added the new nursery rule noJsxPropsBind. This rule disallows .bind(), arrow functions, or function expressions in JSX props.

Invalid:
```
<Foo onClick={() => console.log("Hello!")}></Foo>
```
#8523 5f22f1c Thanks @ematipico! - Improved the diagnostics of nursery rules. Added a message to diagnostics emitted by nursery rules, so that users are aware of nature of nursery rules.
#8571 03666fd Thanks @dyc3! - Improved the performance of noRedeclare by eliminating string allocations
#8591 9dd9ca7 Thanks @Netail! - Added the nursery rule useUniqueArgumentNames. Enforce unique arguments for GraphQL fields & directives.

Invalid:
```
query {
  field(arg1: "value", arg1: "value")
}
```
#8521 a704be9 Thanks @ToBinio! - Update useVueDefineMacrosOrder to only run on <script setup> blocks.
#8344 7b982ba Thanks @ematipico! - Reduced the system calls when running the CLI. The performances might be noticeable in big projects that have multiple libraries and enable project rules.
#8588 958e24b Thanks @Netail! - Added the nursery rule useUniqueVariableNames. Enforce unique variable names for GraphQL operations.

Invalid:
```
query ($x: Int, $x: Int) {
  field
}
```
#8529 8794883 Thanks @mdevils! - Fixed #8499: useExhaustiveDependencies properly handles aliased destructured object keys when using stableResult configuration.
#8557 4df2f4d Thanks @dyc3! - Fixed an issue with the HTML formatter where it wouldn't add a space before the /> in self closing elements. This brings the HTML formatter more in line with Prettier.
```
-<Component/>
+<Component />
```
#8509 574a909 Thanks @ematipico! - Added support for parsing and formatting the Svelte {#snippet} syntax, when html.experimentalFullSupportEnabled is set to true.
```
-{#snippet    foo() }
+{#snippet foo()}

{/snippe}
```
#8248 1231a5c Thanks @emilyinure! - Added new nursery rule noReturnAssign, which disallows assignments inside return statements.

Invalid:
```
function f(a) {
  return (a = 1);
}
```
#8531 6b09620 Thanks @taga3s! - Fixed #8472: The CSS parser can now accept multiple comma separated parameters in :active-view-transition-type.
#8615 b9da66d Thanks @taga3s! - Remove next/script component name check from noBeforeInteractiveScriptOutsideDocument since it is a default export.
#8536 efbfbe2 Thanks @dyc3! - Fixed #8527: Improved type inference where analyzing code with repeated object property access and assignments (e.g. node = node.parent, a pattern common when traversing trees in a while loop) could hit an internal type limit. Biome now handles these cases without exceeding the type limit.
#8583 83be210 Thanks @dyc3! - Added the new nursery rule useVueValidVCloak. Enforces that usages of the v-cloak directive in Vue.js SFC are valid.
```

<div v-cloak />


<div v-cloak:aaa />
<div v-cloak.bbb />
<div v-cloak="ccc" />
```
#8583 83be210 Thanks @dyc3! - Added the new nursery rule useVueValidVPre. Enforces that usages of the v-pre directive in Vue.js SFC are valid.
```

<div v-pre />


<div v-pre:aaa />
<div v-pre.bbb />
<div v-pre="ccc" />
```
#8644 a3a27a7 Thanks @JacquesLeupin! - Added the nursery rule useVueVapor to enforce <script setup vapor> in Vue SFCs. For example <script setup> is invalid.
#8508 b86842c Thanks @tt-a1i! - Fixed #6783: now, when a path is provided via --stdin-file-path, Biome checks whether the file exists on disk. If the path doesn't exist (virtual path), ignore checks (files.includes and VCS ignore rules) are skipped.

Effect-TS/language-service (@effect/language-service)

`v0.71.0`

Compare Source

Minor Changes

#619 f171350 Thanks @mattiamanzati! - Add effectSucceedWithVoid diagnostic to suggest using Effect.void instead of Effect.succeed(undefined) or Effect.succeed(void 0).

The diagnostic detects calls to Effect.succeed where the argument is exactly undefined or void 0 (including parenthesized variants) and suggests replacing them with the more idiomatic Effect.void. A quick fix is provided to automatically apply the replacement.

Before:
```
Effect.succeed(undefined);
Effect.succeed(void 0);
```
After:
```
Effect.void;
```

Patch Changes

#621 74ef937 Thanks @mattiamanzati! - Improve diagnostic messages for globalErrorInEffectFailure and globalErrorInEffectCatch to be more concise and actionable.

Before:

The global Error type is used in an Effect failure channel. It's not recommended to use the global Error type in Effect failures as they can get merged together. Instead, use tagged errors or custom errors with a discriminator property to get properly type-checked errors.

After:

Global 'Error' loses type safety as untagged errors merge together in the Effect failure channel. Consider using a tagged error and optionally wrapping the original in a 'cause' property.

`v0.70.0`

Compare Source

Minor Changes

#618 ed689f8 Thanks @mattiamanzati! - Improve globalErrorInEffectFailure diagnostic to detect global Error type in any Effect failure channel.

The diagnostic now works by finding new Error() expressions and checking if they end up in an Effect's failure channel, rather than only checking Effect.fail calls. This means it will now detect global Error usage in:
- Effect.fail(new Error(...))
- Effect.gen functions that fail with global Error
- Effect.mapError converting to global Error
- Effect.flatMap chains that include global Error
The diagnostic now reports at the new Error() location for better precision.

Patch Changes

#616 b32da44 Thanks @mattiamanzati! - Improve missedPipeableOpportunity diagnostic message to show the suggested subject for .pipe(...).

Before:

Nested function calls can be converted to pipeable style for better readability.

After:

Nested function calls can be converted to pipeable style for better readability; consider using addOne(5).pipe(...) instead.

`v0.69.2`

Compare Source

Patch Changes

#612 2b49181 Thanks @mattiamanzati! - Improve effectFnIife diagnostic message to suggest Effect.withSpan with the trace name when available

When Effect.fn("traceName") is used as an IIFE, the diagnostic now suggests using Effect.gen with Effect.withSpan("traceName") piped at the end to maintain tracing spans. For Effect.fnUntraced, it simply suggests using Effect.gen without the span suggestion.
#615 ae4f054 Thanks @mattiamanzati! - Improve effectFnOpportunity diagnostic with more specific messages and configurable fixes
- Add new effectFn configuration option to control which code fix variants are offered: "untraced", "span", "inferred-span", "no-span" (defaults to ["span"])
- Diagnostic message now shows the exact expected signature for the rewrite
- Distinguish between explicit trace from Effect.withSpan vs inferred trace from function name
- Skip functions with return type annotations to avoid issues with recursive functions
Before:
```
This function could benefit from Effect.fn's automatic tracing...
```
After:
```
Can be rewritten as a reusable function: Effect.fn("myFunction")(function*() { ... })
```

`v0.69.1`

Compare Source

Patch Changes

#610 990ccbc Thanks @mattiamanzati! - Improve effectFnOpportunity diagnostic message to mention that quickfixes are available in the editor or via the CLI quickfixes command.

`v0.69.0`

Compare Source

Minor Changes

#608 bc7da1e Thanks @mattiamanzati! - Add effectFnIife diagnostic to warn when Effect.fn or Effect.fnUntraced is used as an IIFE (Immediately Invoked Function Expression).

Effect.fn is designed to create reusable functions that can take arguments and provide tracing. When used as an IIFE, Effect.gen is more appropriate.

Example:
```
// Before (triggers warning)
const result = Effect.fn("test")(function* () {
  yield* Effect.succeed(1);
})();

// After (using Effect.gen)
const result = Effect.gen(function* () {
  yield* Effect.succeed(1);
});
```
A quick fix is provided to automatically convert Effect.fn IIFEs to Effect.gen.

`v0.68.0`

Compare Source

Minor Changes

#603 d747210 Thanks @mattiamanzati! - Added instanceOfSchema diagnostic that suggests using Schema.is instead of instanceof for Effect Schema types.

Example:
```
import { Schema } from "effect"

const MySchema = Schema.Struct({ name: Schema.String })

// Before - triggers diagnostic
if (value instanceof MySchema) { ... }

// After - using Schema.is
if (Schema.is(MySchema)(value)) { ... }
```
The diagnostic is disabled by default and can be enabled with instanceOfSchema:suggestion or instanceOfSchema:warning.

Patch Changes

#605 d63d5df Thanks @mattiamanzati! - Improve leakingRequirements diagnostic message for clarity

`v0.67.0`

Compare Source

Minor Changes

#599 4c9f5c7 Thanks @mattiamanzati! - Add quickfixes CLI command that shows diagnostics with available quick fixes and their proposed code changes.

Example usage:
```
# Check a specific file
effect-language-service quickfixes --file ./src/index.ts

# Check an entire project
effect-language-service quickfixes --project ./tsconfig.json
```
The command displays each diagnostic along with the available code fixes and a diff preview of the proposed changes, making it easy to see what automatic fixes are available before applying them.

Patch Changes

#601 c0a6da3 Thanks @mattiamanzati! - Reduce over-suggestion of effectFnOpportunity diagnostic for regular functions.

The diagnostic now only suggests Effect.fn for regular functions (not using Effect.gen) when:
- The function has a block body (not a concise arrow expression)
- The function body has more than 5 statements
Functions using Effect.gen are still always suggested regardless of body size.

`v0.66.1`

Compare Source

Patch Changes

#597 3833a10 Thanks @mattiamanzati! - Improved effectFnOpportunity diagnostic message to mention that Effect.fn accepts piped transformations as additional arguments when pipe transformations are detected.

When a function has .pipe() calls that would be absorbed by Effect.fn, the message now includes: "Effect.fn also accepts the piped transformations as additional arguments."

`v0.65.0`

Compare Source

Minor Changes

#581 4569328 Thanks @mattiamanzati! - Add effectFnOpportunity diagnostic that suggests converting functions returning Effect.gen to Effect.fn for better tracing and concise syntax.

The diagnostic triggers on:
- Arrow functions returning Effect.gen(...)
- Function expressions returning Effect.gen(...)
- Function declarations returning Effect.gen(...)
- Functions with Effect.gen(...).pipe(...) patterns
It provides two code fixes:
- Convert to Effect.fn (traced) - includes the function name as the span name
- Convert to Effect.fnUntraced - without tracing
The diagnostic skips:
- Generator functions (can't be converted)
- Named function expressions (typically used for recursion)
- Functions with multiple call signatures (overloads)
When the original function has a return type annotation, the converted function will use Effect.fn.Return<A, E, R> as the return type.

Example:
```
// Before
export const myFunction = (a: number) =>
  Effect.gen(function* () {
    yield* Effect.succeed(1);
    return a;
  });

// After (with Effect.fn)
export const myFunction = Effect.fn("myFunction")(function* (a: number) {
  yield* Effect.succeed(1);
  return a;
});

// Before (with pipe)
export const withPipe = () =>
  Effect.gen(function* () {
    return yield* Effect.succeed(1);
  }).pipe(Effect.withSpan("withPipe"));

// After (with Effect.fn)
export const withPipe = Effect.fn("withPipe")(function* () {
  return yield* Effect.succeed(1);
}, Effect.withSpan("withPipe"));
```
#575 00aeed0 Thanks @mattiamanzati! - Add effectMapVoid diagnostic that suggests using Effect.asVoid instead of Effect.map(() => void 0), Effect.map(() => undefined), or Effect.map(() => {}).

Also adds two new TypeParser utilities:
- lazyExpression: matches zero-argument arrow functions or function expressions that return a single expression
- emptyFunction: matches arrow functions or function expressions with an empty block body
And adds isVoidExpression utility to TypeScriptUtils for detecting void 0 or undefined expressions.

Example:
```
// Before
Effect.succeed(1).pipe(Effect.map(() => void 0));
Effect.succeed(1).pipe(Effect.map(() => undefined));
Effect.succeed(1).pipe(Effect.map(() => {}));

// After (suggested fix)
Effect.succeed(1).pipe(Effect.asVoid);
```
#582 94d4a6b Thanks @mattiamanzati! - Added layerinfo CLI command that provides detailed information about a specific exported layer.

Features:
- Shows layer type, location, and description
- Lists services the layer provides and requires
- Suggests optimal layer composition order using Layer.provide, Layer.provideMerge, and Layer.merge
Example usage:
```
effect-language-service layerinfo --file ./src/layers/app.ts --name AppLive
```
Also added a tip to both overview and layerinfo commands about using Layer.mergeAll(...) to get suggested composition order.
#583 b0aa78f Thanks @mattiamanzati! - Add redundantSchemaTagIdentifier diagnostic that suggests removing redundant identifier arguments when they equal the tag value in Schema.TaggedClass, Schema.TaggedError, or Schema.TaggedRequest.

Before:
```
class MyError extends Schema.TaggedError<MyError>("MyError")("MyError", {
  message: Schema.String,
}) {}
```
After applying the fix:
```
class MyError extends Schema.TaggedError<MyError>()("MyError", {
  message: Schema.String,
}) {}
```
Also updates the completions to not include the redundant identifier when autocompleting Schema.TaggedClass, Schema.TaggedError, and Schema.TaggedRequest.
#573 6715f91 Thanks @mattiamanzati! - Rename reportSuggestionsAsWarningsInTsc option to includeSuggestionsInTsc and change default to true.

This option controls whether diagnostics with "suggestion" severity are included in TSC output when using the effect-language-service patch feature. When enabled, suggestions are reported as messages in TSC output, which is useful for LLM-based development tools to see all suggestions.

Breaking change: The option has been renamed and the default behavior has changed:
- Old: reportSuggestionsAsWarningsInTsc: false (suggestions not included by default)
- New: includeSuggestionsInTsc: true (suggestions included by default)
To restore the previous behavior, set "includeSuggestionsInTsc": false in your tsconfig.json plugin configuration.
#586 e225b5f Thanks @mattiamanzati! - Add markdown documentation support to setup command

The setup command now automatically manages Effect Language Service documentation in AGENTS.md and CLAUDE.md files:
- When installing: Adds or updates the Effect Language Service section with markers
- When uninstalling: Removes the section if present
- Case-insensitive file detection (supports both lowercase and uppercase filenames)
- Skips symlinked files to avoid modifying linked content
- Shows proper diff view for markdown file changes
Example section added to markdown files:
```


## Effect Language Service

The Effect Language Service comes in with a useful CLI that can help you with commands to get a better understanding your Effect Layers and Services, and to help you compose them correctly.


```

Patch Changes

#580 a45606b Thanks @mattiamanzati! - Add Effect.fn and Effect.fnUntraced support to the piping flows parser.

The piping flows parser now recognizes pipe transformations passed as additional arguments to Effect.fn, Effect.fn("traced"), and Effect.fnUntraced. This enables diagnostics like catchAllToMapError, catchUnfailableEffect, and multipleEffectProvide to work with these patterns.

Example:
```
// This will now trigger the catchAllToMapError diagnostic
const example = Effect.fn(
  function* () {
    return yield* Effect.fail("error");
  },
  Effect.catchAll((cause) => Effect.fail(new MyError(cause)))
);
```
#587 7316859 Thanks @mattiamanzati! - Mark deprecated TypeScript Signature methods and migrate to property accessors

Added @deprecated annotations to TypeScript Signature interface methods (getParameters, getTypeParameters, getDeclaration, getReturnType, getTypeParameterAtPosition) with guidance to use their modern property alternatives. Updated codebase usage of getParameters() to use .parameters property instead.
#584 ed12861 Thanks @mattiamanzati! - Fix TypeError in setup command when updating existing diagnosticSeverity configuration

The setup command was throwing TypeError: Cannot read properties of undefined (reading 'text') when trying to update the diagnosticSeverity option of an existing @effect/language-service plugin configuration in tsconfig.json.

This occurred because TypeScript's ChangeTracker formatter needed to compute indentation by traversing the AST tree, which failed when replacing a PropertyAssignment node inside a nested list context.

The fix replaces just the initializer value (ObjectLiteralExpression) instead of the entire PropertyAssignment, avoiding the problematic list indentation calculation.
#585 7ebe5db Thanks @mattiamanzati! - Enhanced layerinfo CLI command with output type selection for layer composition.

New Features:
- Added --outputs option to select which output types to include in the suggested composition (e.g., --outputs 1,2,3)
- Shows all available output types from the layer graph with indexed checkboxes
- By default, only types that are in the layer's declared ROut are selected
- Composition code now includes export const <name> = ... prefix for easy copy-paste
Example output:
```
Suggested Composition:
  Not sure you got your composition right? Just write all layers inside a Layer.mergeAll(...)
  then run this command again and use --outputs to select which outputs to include in composition.
  Example: --outputs 1,2,3

  [ ] 1. Cache
  [x] 2. UserRepository

  export const simplePipeIn = UserRepository.Default.pipe(
    Layer.provide(Cache.Default)
  )
```
This allows users to see all available outputs from a layer composition and choose which ones to include in the suggested composition order.
#577 0ed50c3 Thanks @mattiamanzati! - Refactor catchAllToMapError diagnostic to use the piping flows parser for detecting Effect.catchAll calls.

This change also:
- Makes outType optional in ParsedPipingFlowSubject to handle cases where type information is unavailable
- Sorts piping flows by position for consistent ordering
#578 cab6ce8 Thanks @mattiamanzati! - refactor: use piping flows parser in catchUnfailableEffect diagnostic
#579 2a82522 Thanks @mattiamanzati! - refactor: use piping flows parser in multipleEffectProvide diagnostic
#570 0db6e28 Thanks @mattiamanzati! - Refactor CLI overview command to extract symbol collection logic into reusable utility
- Extract collectSourceFileExportedSymbols into src/cli/utils/ExportedSymbols.ts for reuse across CLI commands
- Add --max-symbol-depth option to overview command (default: 3) to control how deep to traverse nested symbol properties
- Add tests for the overview command with snapshot testing
#574 9d0695e Thanks @mattiamanzati! - Remove deprecated ts-patch documentation from README. The Effect LSP CLI Patch is now the only recommended approach for getting diagnostics at compile time.
#576 5017d75 Thanks @mattiamanzati! - Add piping flows parser for caching piping flow analysis per source file.

This internal improvement introduces a pipingFlows function in TypeParser that analyzes and caches all piping flows (both pipe() calls and .pipe() method chains) in a source file. The parser:
- Identifies piping flows including nested pipes and mixed call styles (e.g., Effect.map(effect, fn).pipe(...))
- Tracks the subject, transformations, and intermediate types for each flow
- Enables more efficient diagnostic implementations by reusing cached analysis
The missedPipeableOpportunity diagnostic has been refactored to use this new parser, improving performance when analyzing files with multiple piping patterns.

`v0.64.1`

Compare Source

Patch Changes

#568 477271d Thanks @mattiamanzati! - Fix auto-import with namespace import packages generating malformed code when the identifier is at the beginning of the file.

When using namespaceImportPackages configuration and auto-completing an export like isAnyKeyword from effect/SchemaAST, the code was incorrectly generated as:
```
SchemaAST.import * as SchemaAST from "effect/SchemaAST";
```
Instead of the expected:
```
import * as SchemaAST from "effect/SchemaAST";

SchemaAST.isAnyKeyword;
```
The fix ensures the import statement is added before the namespace prefix when both changes target position 0.

`v0.64.0`

Compare Source

Minor Changes

#567 dcb3fe5 Thanks @mattiamanzati! - Added new diagnostic catchAllToMapError that suggests using Effect.mapError instead of Effect.catchAll + Effect.fail when the callback only wraps the error.

Before:
```
Effect.catchAll((cause) => Effect.fail(new MyError(cause)));
```
After:
```
Effect.mapError((cause) => new MyError(cause));
```
The diagnostic includes a quick fix that automatically transforms the code.
#555 0424000 Thanks @mattiamanzati! - Add globalErrorInEffectCatch diagnostic to detect global Error types in catch callbacks

This new diagnostic warns when catch callbacks in Effect.tryPromise, Effect.try, Effect.tryMap, or Effect.tryMapPromise return the global Error type instead of typed errors.

Using the global Error type in Effect failures is not recommended as they can get merged together, making it harder to distinguish between different error cases. Instead, it's better to use tagged errors (like Data.TaggedError) or custom errors with discriminator properties to enable proper type checking and error handling.

Example of code that triggers the diagnostic:
```
Effect.tryPromise({
  try: () => fetch("http://example.com"),
  catch: () => new Error("Request failed"), // ⚠️ Warning: returns global Error type
});
```
Recommended approach:
```
class FetchError extends Data.TaggedError("FetchError")<{
  cause: unknown;
}> {}

Effect.tryPromise({
  try: () => fetch("http://example.com"),
  catch: (e) => new FetchError({ cause: e }), // ✅ Uses typed error
});
```
This diagnostic also improves the clarity message for the leakingRequirements diagnostic by adding additional guidance on how services should be collected in the layer creation body.

#558 cc5feb1 Thanks @mattiamanzati! - Add layerMergeAllWithDependencies diagnostic to detect interdependencies in Layer.mergeAll calls

This new diagnostic warns when Layer.mergeAll is called with layers that have interdependencies, where one layer provides a service that another layer in the same call requires.

Layer.mergeAll creates layers in parallel, so dependencies between layers will not be satisfied. This can lead to runtime errors when trying to use the merged layer.

Example of code that triggers the diagnostic:

export class DbConnection extends Effect.Service<DbConnection>()(
  "DbConnection",
  {
    succeed: {},
  }
) {}
export class FileSystem extends Effect.Service<FileSystem>()("FileSystem", {
  succeed: {},
}) {}
export class Cache extends Effect.Service<Cache>()("Cache", {
  effect: Effect.as(FileSystem, {}), // Cache requires FileSystem
}) {}

// ⚠️ Warning on FileSystem.Default
const layers = Layer.mergeAll(
  DbConnection.Default,
  FileSystem.Default, // This provides FileSystem
  Cache.Default // This requires FileSystem
);

Recommended approach:

// Provide FileSystem separately before merging
const layers = Layer.mergeAll(DbConnection.Default, Cache.Default).pipe(
  Layer.provideMerge(FileSystem.Default)
);

The diagnostic correctly handles pass-through layers (layers that both provide and require the same type) and only reports on layers that actually provide dependencies needed by other layers in the same mergeAll call.

#557 83ce411 Thanks @mattiamanzati! - Add missingLayerContext diagnostic to detect missing service requirements in Layer definitions

This new diagnostic provides better error readability when you're missing service requirements in your Layer type definitions. It works similarly to the existing missingEffectContext diagnostic but specifically checks the RIn (requirements input) parameter of Layer types.

Example of code that triggers the diagnostic:
```
import * as Effect from "effect/Effect";
import * as Layer from "effect/Layer";

class ServiceA extends Effect.Service<ServiceA>()("ServiceA", {
  succeed: { a: 1 },
}) {}

class ServiceB extends Effect.Service<ServiceB>()("ServiceB", {
  succeed: { a: 2 },
}) {}

declare const layerWithServices: Layer.Layer<ServiceA, never, ServiceB>;

function testFn(layer: Layer.Layer<ServiceA>) {
  return layer;
}

// ⚠️ Error: Missing 'ServiceB' in the expected Layer context.
testFn(layerWithServices);
```
The diagnostic helps catch type mismatches early by clearly indicating which service requirements are missing when passing layers between functions or composing layers together.
#562 57d5af2 Thanks @mattiamanzati! - Add overview CLI command that provides an overview of Effect-related exports in a project.

The command analyzes TypeScript files and reports all exported yieldable errors, services (Context.Tag, Effect.Tag, Effect.Service), and layers with their types, file locations, and JSDoc descriptions. A progress spinner shows real-time file processing status.

Usage:
```
effect-language-service overview --file path/to/file.ts
effect-language-service overview --project tsconfig.json
```
Example output:
```
✔ Processed 3 file(s)
Overview for 3 file(s).

Yieldable Errors (1)
  NotFoundError
    ./src/errors.ts:5:1
```

Configuration

📅 Schedule: Branch creation - Between 12:00 AM and 03:59 AM, only on Monday ( * 0-3 * * 1 ) (UTC), 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 requested a review from a team as a code owner January 12, 2026 01:06

renovate bot added the dependencies label Jan 12, 2026

renovate bot force-pushed the renovate/all-minor-patch branch 3 times, most recently from ce0ea83 to 3374763 Compare January 19, 2026 18:05

renovate bot force-pushed the renovate/all-minor-patch branch 3 times, most recently from 0a86f1b to 729186b Compare January 22, 2026 18:06

chore(deps): update all non-major dependencies

1139754

renovate bot force-pushed the renovate/all-minor-patch branch from 729186b to 1139754 Compare January 22, 2026 20:57

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Uh oh!

chore(deps): update all non-major dependencies #6

chore(deps): update all non-major dependencies #6

Uh oh!

renovate bot commented Jan 12, 2026 •

edited

Loading

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

1 participant

Uh oh!

chore(deps): update all non-major dependencies #6

Are you sure you want to change the base?

chore(deps): update all non-major dependencies #6

Uh oh!

Conversation

renovate bot commented Jan 12, 2026 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Release Notes

Patch Changes

Invalid

Valid

Minor Changes

Patch Changes

Minor Changes

Patch Changes

Patch Changes

Patch Changes

Minor Changes

Minor Changes

Patch Changes

Minor Changes

Patch Changes

Patch Changes

Minor Changes

Patch Changes

Patch Changes

Minor Changes

Configuration

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

1 participant

renovate bot commented Jan 12, 2026 •

edited

Loading