chore(deps): update all non-major dependencies by renovate[bot] · Pull Request #6 · withstudiocms/bots

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.14`
@effect/language-service	`^0.44.0` → `^0.73.1`
tsdown (source)	`^0.15.7` → `^0.20.3`

Release Notes

biomejs/biome (@biomejs/biome)

`v2.3.14`

Compare Source

Patch Changes

#8921 29e2435 Thanks @siketyan! - Fixed #8759: The useConsistentTypeDefinitions rule no longer converts empty object type declarations into interfaces, as it will conflict with the noEmptyInterface rule and can cause an infinite loop when both rules are enabled.
#8928 ccaeac4 Thanks @taga3s! - Added the nursery rule useGlobalThis. This rule enforces using globalThis over window, self and global.
#8602 9a18daa Thanks @dyc3! - Added the new nursery rule noVueArrowFuncInWatch. This rule forbids using arrow functions in watchers in Vue components, because arrow functions do not give access to the component instance (via this), while regular functions do.
#8905 9b1eea8 Thanks @ryan-m-walker! - Fixed #8428: Improved parsing recovery when encountering qualified rules inside CSS @page at-rule blocks.
#8900 f788cff Thanks @mdevils! - Fixed #8802: useExhaustiveDependencies now correctly suggests dependencies without including callback-scoped variables or method names.

When accessing object properties with a callback-scoped variable, only the object path is suggested:
```
// Now correctly suggests `props.value` instead of `props.value[day]`
useMemo(() => {
  return WeekdayValues.filter((day) => props.value[day]);
}, [props.value]);
```
When calling methods on objects, only the object is suggested as a dependency:
```
// Now correctly suggests `props.data` instead of `props.data.forEach`
useMemo(() => {
  props.data.forEach((item) => console.log(item));
}, [props.data]);
```
#8913 e1e20ea Thanks @dyc3! - Fixed #8363: HTML parser no longer crashes when encountering a < character followed by a digit in text content (e.g., <12 months). The parser now correctly emits an "Unescaped < bracket character" error instead of treating <12 as a tag name and crashing.
#8910 2fb63a4 Thanks @dyc3! - Fixed #8774: Type aliases with generic parameters that have extends constraints now properly indent comments after the equals sign.

Previously, comments after the = in type aliases with extends constraints were not indented:
```
-type A<B, C extends D> = // Some comment
-undefined;
+type A<B, C extends D> =
+    // Some comment
+    undefined;
```
#8916 ea4bd04 Thanks @ryan-m-walker! - Fixed #4013, where comments in member chains caused unnecessary line breaks.
```
// Before
aFunction.b().c.d();

// After
aFunction.b().c.d();
```

#8945 fa66fe3 Thanks @fireairforce! - Fixed #8354: Don't remove quotes when type memeber is new.

// Input:
type X = {
  "new"(): string;
  "foo"(): string;
};

// Format Output:
type X = {
  "new()": string;
  foo(): string;
};

#8927 0ef3da5 Thanks @littleKitchen! - Fixed #8907: useExhaustiveDependencies now correctly recognizes stable hook results (like useState setters and useRef values) when declared with let.
#8931 4561751 Thanks @koshin01! - Added the new nursery rule noRedundantDefaultExport, which flags redundant default exports where the default export references the same identifier as a named export.

#8900 f788cff Thanks @mdevils! - Fixed #8883: useExhaustiveDependencies no longer produces false positives when props are destructured in the function body of arrow function components without parentheses around the parameter.

type Props = { msg: string };

// Arrow function without parentheses around `props`
const Component: React.FC<Props> = (props) => {
  const { msg } = props;
  // Previously, this incorrectly reported `msg` as unnecessary
  useEffect(() => console.log(msg), [msg]);
};

#8861 3531687 Thanks @dyc3! - Added the noDeprecatedMediaType CSS rule to flag deprecated media types like tv and handheld.
#8775 7ea71cd Thanks @igas! - Fixed the noUnnecessararyConditions rule to prevent trigger for optional fallback patterns.
#8860 95f1eea Thanks @dyc3! - Added the nursery rule noHexColors, which flags the use of hexadecimal color codes in CSS and suggests using named colors or RGB/RGBA/HSL/HSLA formats instead.
#8786 d876a38 Thanks @Bertie690! - Added the nursery rule useConsistentMethodSignatures.
Inspired by the similarly named version from typescript-eslint, this rule aims to enforce a consistent style for methods used inside object types and interfaces.

Examples

Invalid code with style set to "property" (the default):

interface Foo {
  method(a: string): void;
}

Invalid code with style set to "method":

type Bar = {
  prop: (a: string) => void;
}

#8864 5e97119 Thanks @dyc3! - Improved the summary provided by biome migrate eslint to be clearer on why rules were not migrated. Biome now specifies a reason when a rule is not migrated, such as being incompatible with the formatter or not implemented yet. This helps users make more informed decisions when migrating their ESLint configurations to Biome.
#8924 99b4cd1 Thanks @tmohammad78! - Fixed #8920: noUnknownFunction now knows about sibling-count, and sibling-index css functions

#8900 f788cff Thanks @mdevils! - Fixed #8885: useExhaustiveDependencies no longer incorrectly reports variables as unnecessary dependencies when they are derived from expressions containing post/pre-increment operators (++/--) or compound assignment operators (+=, -=, etc.).

let renderCount = 0;

export const MyComponent = () => {
  // `count` is now correctly recognized as a required dependency
  // because `renderCount++` can produce different values between renders
  const count = renderCount++;

  useEffect(() => {
    console.log(count);
  }, [count]); // no longer reports `count` as unnecessary
};

#8619 d78e01d Thanks @Netail! - Added the nursery rule useInputName. Require mutation arguments to be called “input”, and the input type to be called Mutation name + “Input”.

Invalid:
```
type Mutation {
  SetMessage(message: String): String
}
```
#8922 871b45e Thanks @siketyan! - Fixed #8829: Revamped the noGlobalDirnameFilename rule to catch many false negatives that have not been reported.

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

`v0.73.1`

Compare Source

Patch Changes

#639 ff72045 Thanks @mattiamanzati! - Add wildcard (*) support for @effect-diagnostics comment directives. You can now use * as a rule name to apply a severity override to all diagnostics at once, e.g. @effect-diagnostics *:off disables all Effect diagnostics from that point on. Rule-specific overrides still take precedence over wildcard overrides.

`v0.73.0`

Compare Source

Minor Changes

#637 616c2cc Thanks @mattiamanzati! - Add Effect v4 completions support
- Detect installed Effect version (v3 or v4) and conditionally enable version-specific completions
- Add Schema.ErrorClass and Schema.RequestClass completions for Effect v4
- Disable v3-only completions (Effect.Service, Effect.Tag, Schema.TaggedError, Schema.TaggedClass, Schema.TaggedRequest, Context.Tag self, Rpc.make classes, Schema.brand, Model.Class) when Effect v4 is detected
- Support lowercase taggedEnum in addition to TaggedEnum for v4 API compatibility

`v0.72.1`

Compare Source

Patch Changes

#635 b16fd37 Thanks @mattiamanzati! - Fix effectGenToFn refactor to convert Effect<A, E, R> return types to Effect.fn.Return<A, E, R>

Before this fix, the "Convert to fn" refactor would keep the original Effect.Effect<A, E, R> return type, producing code that doesn't compile. Now it correctly transforms the return type:

// Before refactor
const someFunction = (value: string): Effect.Effect<number, boolean> =>
  Effect.gen(function* () {
    /* ... */
  });

// After refactor (fixed)
const someFunction = Effect.fn("someFunction")(function* (
  value: string
): Effect.fn.Return<number, boolean, never> {
  /* ... */
});

#630 689a012 Thanks @mattiamanzati! - Restructure test harness setup by moving shared test utilities and updating package dependencies

`v0.72.0`

Compare Source

Minor Changes

#627 a34f997 Thanks @mattiamanzati! - Refactor internal structure and harness

`v0.71.2`

Compare Source

Patch Changes

#625 422087d Thanks @mattiamanzati! - Fix CLI patching to target emitFilesAndReportErrors function instead of emitFilesAndReportErrorsAndGetExitStatus, updating the injection approach to replace the diagnostics property in the return statement's object literal.

`v0.71.1`

Compare Source

Patch Changes

#624 d279457 Thanks @mattiamanzati! - Add ignoreEffectSuggestionsInTscExitCode option (default: true) to control whether Effect-related suggestions affect the TSC exit code. When enabled, suggestions won't cause tsc to return a non-zero exit code.
#622 5eab20a Thanks @mattiamanzati! - Add ignoreEffectWarningsInTscExitCode option to allow Effect-related warnings to not affect the TSC exit code. When enabled, tsc will compile successfully even if Effect warnings are emitted. This is useful for CI/CD pipelines where Effect diagnostics should be informational rather than blocking.

`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
    NotFoundError

Services (2)
  DbConnection
    ./src/services/db.ts:6:1
    Manages database connections

Layers (1)
  AppLive
    ./src/layers/app.ts:39:14
    Layer<Cache | UserRepository, never, never>

Patch Changes

#561 c3b3bd3 Thanks @mattiamanzati! - Add descriptions to CLI commands using Command.withDescription for improved help output when using --help flag.
#565 2274aef Thanks @mattiamanzati! - Fix unnecessaryPipe diagnostic and refactor not working with namespace imports from effect/Function (e.g., Function.pipe() or Fn.pipe())

#560 75a480e Thanks @mattiamanzati! - Improve diagnostic message for unsupportedServiceAccessors when used with Effect.Tag

When the unsupportedServiceAccessors diagnostic is triggered on an Effect.Tag class (which doesn't allow disabling accessors), the message now includes a helpful suggestion to use Context.Tag instead:

export class MyService extends Effect.Tag("MyService")<
  MyService,
  {
    method: <A>(value: A) => Effect.Effect<A>;
  }
>() {}
// Diagnostic: Even if accessors are enabled, accessors for 'method' won't be available
// because the signature have generic type parameters or multiple call signatures.
// Effect.Tag does not allow to disable accessors, so you may want to use Context.Tag instead.

#559 4c1f809 Thanks @mattiamanzati! - Improve Layer Magic refactor ordering by considering both provided and required service counts

The Layer Magic refactor now uses a combined ordering heuristic that considers both:
1. The number of services a layer provides
2. The number of services a layer requires
This results in more optimal layer composition order, especially in complex dependency graphs where layers have varying numbers of dependencies.
#566 036c491 Thanks @mattiamanzati! - Simplify diagnostic messages for global Error type usage

The diagnostic messages for globalErrorInEffectCatch and globalErrorInEffectFailure now use the more generic term "tagged errors" instead of "tagged errors (Data.TaggedError)" to provide cleaner, more concise guidance.

`v0.63.2`

Compare Source

Patch Changes

#553 [e64e3df](https://redirect.github.c

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 10 times, most recently from 3ab8542 to 1ac6aca Compare January 26, 2026 17:14

renovate bot force-pushed the renovate/all-minor-patch branch 2 times, most recently from 56a20dc to 5afd9d0 Compare February 2, 2026 03:17

renovate bot force-pushed the renovate/all-minor-patch branch 6 times, most recently from ca7b185 to 02b6dd1 Compare February 12, 2026 10:52

chore(deps): update all non-major dependencies

d5c7b1f

renovate bot force-pushed the renovate/all-minor-patch branch from 02b6dd1 to d5c7b1f Compare February 12, 2026 17:46

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
renovate[bot] wants to merge 1 commit intomainfrom
renovate/all-minor-patch

renovate bot commented Jan 12, 2026 •

edited

Loading

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

0 participants

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

Examples

Patch Changes

Minor Changes

Patch Changes

Minor Changes

Patch Changes

Patch Changes

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

Patch Changes

Patch Changes

Configuration

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

0 participants

renovate bot commented Jan 12, 2026 •

edited

Loading