Update dependency @effect/language-service to ^0.77.0

Fix
useContext -> useContextFromLayer
2026-02-27 12:01:47 +00:00 · 2026-02-27 10:49:54 +01:00 · 2026-02-27 10:45:08 +01:00 · 2026-02-27 10:16:52 +01:00 · 2026-02-25 22:33:18 +01:00 · 2026-02-25 03:18:24 +01:00
13 changed files with 520 additions and 167 deletions
--- a/README.md
+++ b/README.md
@@ -1,6 +1,6 @@
 # Effect FC Monorepo
-[Effect-TS](https://effect.website/) integration for React 19+ that allows you to write function components using Effect generators.
+[Effect-TS](https://effect.website/) integration for React 19.2+ that allows you to write function components using Effect generators.
 This monorepo contains:
 - [The `effect-fc` library](packages/effect-fc)
--- a/bun.lock
+++ b/bun.lock
@@ -6,7 +6,7 @@
      "name": "@effect-fc/monorepo",
      "devDependencies": {
        "@biomejs/biome": "^2.3.11",
-        "@effect/language-service": "^0.72.0",
+        "@effect/language-service": "^0.77.0",
        "@types/bun": "^1.3.6",
        "npm-check-updates": "^19.3.1",
        "npm-sort": "^0.0.4",
@@ -16,7 +16,7 @@
    },
    "packages/effect-fc": {
      "name": "effect-fc",
-      "version": "0.2.2",
+      "version": "0.2.3",
      "devDependencies": {
        "@effect/platform-browser": "^0.74.0",
      },
@@ -116,7 +116,7 @@
    "@effect-fc/example": ["@effect-fc/example@workspace:packages/example"],
-    "@effect/language-service": ["@effect/language-service@0.72.0", "", { "bin": { "effect-language-service": "cli.js" } }, "sha512-MWkyTPCXSs5Q3OIBWR3q24SA+ipkdWW7EBJBt6EPUzlzZxjJLXtLBhXpMoCFheSEM0FTWOHT4BRLh5lufsmjVw=="],
+    "@effect/language-service": ["@effect/language-service@0.77.0", "", { "bin": { "effect-language-service": "cli.js" } }, "sha512-QP2bri8DdcK7Eo+SqFS2yNeD0Ch9kKHYxq2jeE9CaPpBknevCNFb3+hT6qSsPt2P6yOkhNP83KMy5Uk7DGBXlg=="],
    "@effect/platform": ["@effect/platform@0.94.2", "", { "dependencies": { "find-my-way-ts": "^0.1.6", "msgpackr": "^1.11.4", "multipasta": "^0.2.7" }, "peerDependencies": { "effect": "^3.19.15" } }, "sha512-85vdwpnK4oH/rJ3EuX/Gi2Hkt+K4HvXWr9bxCuqvty9hxyEcRxkJcqTesYrcVoQB6aULb1Za2B0MKoTbvffB3Q=="],
--- a/package.json
+++ b/package.json
@@ -16,7 +16,7 @@
  },
  "devDependencies": {
    "@biomejs/biome": "^2.3.11",
-    "@effect/language-service": "^0.72.0",
+    "@effect/language-service": "^0.77.0",
    "@types/bun": "^1.3.6",
    "npm-check-updates": "^19.3.1",
    "npm-sort": "^0.0.4",
--- a/packages/effect-fc/src/Async.ts
+++ b/packages/effect-fc/src/Async.ts
@@ -7,29 +7,27 @@ import * as Component from "./Component.js"
 export const TypeId: unique symbol = Symbol.for("@effect-fc/Async/Async")
 export type TypeId = typeof TypeId
-export interface Async extends Async.Options {
+export interface Async extends AsyncOptions {
    readonly [TypeId]: TypeId
 }
-export namespace Async {
+export interface AsyncOptions {
    export interface Options {
    readonly defaultFallback?: React.ReactNode
 }
-    export type Props = Omit<React.SuspenseProps, "children">
+export type AsyncProps = Omit<React.SuspenseProps, "children">
 }
-const AsyncProto = Object.freeze({
+export const AsyncPrototype = Object.freeze({
    [TypeId]: TypeId,
-    makeFunctionComponent<P extends {}, A extends React.ReactNode, E, R>(
+    asFunctionComponent<P extends {}, A extends React.ReactNode, E, R>(
        this: Component.Component<P, A, E, R> & Async,
        runtimeRef: React.RefObject<Runtime.Runtime<Exclude<R, Scope.Scope>>>,
    ) {
        const SuspenseInner = (props: { readonly promise: Promise<React.ReactNode> }) => React.use(props.promise)
-        return ({ fallback, name, ...props }: Async.Props) => {
+        return ({ fallback, name, ...props }: AsyncProps) => {
            const promise = Runtime.runPromise(runtimeRef.current)(
                Effect.andThen(
                    Component.useScope([], this),
@@ -54,7 +52,7 @@ export const async = <T extends Component.Component<any, any, any, any>>(
 ): (
    & Omit<T, keyof Component.Component.AsComponent<T>>
    & Component.Component<
-        Component.Component.Props<T> & Async.Props,
+        Component.Component.Props<T> & AsyncProps,
        Component.Component.Success<T>,
        Component.Component.Error<T>,
        Component.Component.Context<T>
@@ -63,22 +61,22 @@ export const async = <T extends Component.Component<any, any, any, any>>(
 ) => Object.setPrototypeOf(
    Object.assign(function() {}, self),
    Object.freeze(Object.setPrototypeOf(
-        Object.assign({}, AsyncProto),
+        Object.assign({}, AsyncPrototype),
        Object.getPrototypeOf(self),
    )),
 )
 export const withOptions: {
    <T extends Component.Component<any, any, any, any> & Async>(
-        options: Partial<Async.Options>
+        options: Partial<AsyncOptions>
    ): (self: T) => T
    <T extends Component.Component<any, any, any, any> & Async>(
        self: T,
-        options: Partial<Async.Options>,
+        options: Partial<AsyncOptions>,
    ): T
 } = Function.dual(2, <T extends Component.Component<any, any, any, any> & Async>(
    self: T,
-    options: Partial<Async.Options>,
+    options: Partial<AsyncOptions>,
 ): T => Object.setPrototypeOf(
    Object.assign(function() {}, self, options),
    Object.getPrototypeOf(self),
--- a/packages/effect-fc/src/Component.ts
+++ b/packages/effect-fc/src/Component.ts
@@ -1,25 +1,17 @@
 /** biome-ignore-all lint/complexity/noBannedTypes: {} is the default type for React props */
 /** biome-ignore-all lint/complexity/useArrowFunction: necessary for class prototypes */
-import { Context, type Duration, Effect, Effectable, Equivalence, ExecutionStrategy, Exit, Fiber, Function, HashMap, Layer, ManagedRuntime, Option, Predicate, Ref, Runtime, Scope, Tracer, type Utils } from "effect"
+import { Context, type Duration, Effect, Equivalence, ExecutionStrategy, Exit, Fiber, Function, HashMap, identity, Layer, ManagedRuntime, Option, Pipeable, Predicate, Ref, Runtime, Scope, Tracer, type Utils } from "effect"
 import * as React from "react"
 import { Memoized } from "./index.js"
 export const TypeId: unique symbol = Symbol.for("@effect-fc/Component/Component")
 export type TypeId = typeof TypeId
 /**
- * Interface representing an Effect-based React Component.
+ * Represents an Effect-based React Component that integrates the Effect system with React.
 *
 * This is both:
 * - an Effect that produces a React function component
 * - a constructor-like object with component metadata and options
 */
 export interface Component<P extends {}, A extends React.ReactNode, E, R>
-extends
+extends ComponentPrototype<P, A, R>, ComponentOptions {
    Effect.Effect<(props: P) => A, never, Exclude<R, Scope.Scope>>,
    Component.Options
 {
    new(_: never): Record<string, never>
    readonly [TypeId]: TypeId
    readonly "~Props": P
@@ -28,11 +20,6 @@ extends
    readonly "~Context": R
    readonly body: (props: P) => Effect.Effect<A, E, R>
    /** @internal */
    makeFunctionComponent(
        runtimeRef: React.Ref<Runtime.Runtime<Exclude<R, Scope.Scope>>>
    ): (props: P) => A
 }
 export declare namespace Component {
@@ -42,56 +29,29 @@ export declare namespace Component {
    export type Context<T extends Component<any, any, any, any>> = [T] extends [Component<infer _P, infer _A, infer _E, infer R>] ? R : never
    export type AsComponent<T extends Component<any, any, any, any>> = Component<Props<T>, Success<T>, Error<T>, Context<T>>
    /**
     * Options that can be set on the component
     */
    export interface Options {
        /** Custom displayName for React DevTools and debugging. */
        readonly displayName?: string
        /**
         * Strategy used when executing finalizers on unmount/scope close.
         * @default ExecutionStrategy.sequential
         */
        readonly finalizerExecutionStrategy: ExecutionStrategy.ExecutionStrategy
        /**
         * Debounce time before executing finalizers after component unmount.
         * Helps avoid unnecessary work during fast remount/remount cycles.
         * @default "100 millis"
         */
        readonly finalizerExecutionDebounce: Duration.DurationInput
    }
 }
-const ComponentProto = Object.freeze({
+export interface ComponentPrototype<P extends {}, A extends React.ReactNode, R>
-    ...Effectable.CommitPrototype,
+extends Pipeable.Pipeable {
    readonly [TypeId]: TypeId
    readonly use: Effect.Effect<(props: P) => A, never, Exclude<R, Scope.Scope>>
    asFunctionComponent(
        runtimeRef: React.Ref<Runtime.Runtime<Exclude<R, Scope.Scope>>>
    ): (props: P) => A
    setFunctionComponentName(f: React.FC<P>): void
    transformFunctionComponent(f: React.FC<P>): React.FC<P>
 }
 export const ComponentPrototype: ComponentPrototype<any, any, any> = Object.freeze({
    [TypeId]: TypeId,
    ...Pipeable.Prototype,
-    commit: Effect.fnUntraced(function* <P extends {}, A extends React.ReactNode, E, R>(
+    get use() { return use(this) },
        this: Component<P, A, E, R>
    ) {
        // biome-ignore lint/style/noNonNullAssertion: React ref initialization
        const runtimeRef = React.useRef<Runtime.Runtime<Exclude<R, Scope.Scope>>>(null!)
        runtimeRef.current = yield* Effect.runtime<Exclude<R, Scope.Scope>>()
-        return yield* React.useState(() => Runtime.runSync(runtimeRef.current)(Effect.cachedFunction(
+    asFunctionComponent<P extends {}, A extends React.ReactNode, E, R>(
            (_services: readonly any[]) => Effect.sync(() => {
                const f: React.FC<P> = this.makeFunctionComponent(runtimeRef)
                f.displayName = this.displayName ?? "Anonymous"
                return Memoized.isMemoized(this)
                    ? React.memo(f, this.propsAreEqual)
                    : f
            }),
            Equivalence.array(Equivalence.strict()),
        )))[0](Array.from(
            Context.omit(...nonReactiveTags)(runtimeRef.current.context).unsafeMap.values()
        ))
    }),
    makeFunctionComponent<P extends {}, A extends React.ReactNode, E, R>(
        this: Component<P, A, E, R>,
        runtimeRef: React.RefObject<Runtime.Runtime<Exclude<R, Scope.Scope>>>,
    ) {
@@ -102,14 +62,69 @@ const ComponentProto = Object.freeze({
            )
        )
    },
    setFunctionComponentName<P extends {}, A extends React.ReactNode, E, R>(
        this: Component<P, A, E, R>,
        f: React.FC<P>,
    ) {
        f.displayName = this.displayName ?? "Anonymous"
    },
    transformFunctionComponent: identity,
 } as const)
-const defaultOptions: Component.Options = {
+const use = Effect.fnUntraced(function* <P extends {}, A extends React.ReactNode, E, R>(
    self: Component<P, A, E, R>
 ) {
    // biome-ignore lint/style/noNonNullAssertion: React ref initialization
    const runtimeRef = React.useRef<Runtime.Runtime<Exclude<R, Scope.Scope>>>(null!)
    runtimeRef.current = yield* Effect.runtime<Exclude<R, Scope.Scope>>()
    return yield* React.useState(() => Runtime.runSync(runtimeRef.current)(Effect.cachedFunction(
        (_services: readonly any[]) => Effect.sync(() => {
            const f: React.FC<P> = self.asFunctionComponent(runtimeRef)
            self.setFunctionComponentName(f)
            return self.transformFunctionComponent(f)
        }),
        Equivalence.array(Equivalence.strict()),
    )))[0](Array.from(
        Context.omit(...nonReactiveTags)(runtimeRef.current.context).unsafeMap.values()
    ))
 })
 export interface ComponentOptions {
    /**
     * Custom display name for the component in React DevTools and debugging utilities.
     * Improves developer experience by providing meaningful component identification.
     */
    readonly displayName?: string
    /**
     * Specifies the execution strategy for finalizers when the component unmounts or its scope closes.
     * Determines whether finalizers execute sequentially or in parallel.
     *
     * @default ExecutionStrategy.sequential
     */
    readonly finalizerExecutionStrategy: ExecutionStrategy.ExecutionStrategy
    /**
     * Debounce duration before executing finalizers after component unmount.
     * Prevents unnecessary cleanup work during rapid remount/unmount cycles,
     * which is common in development and certain UI patterns.
     *
     * @default "100 millis"
     */
    readonly finalizerExecutionDebounce: Duration.DurationInput
 }
 export const defaultOptions: ComponentOptions = {
    finalizerExecutionStrategy: ExecutionStrategy.sequential,
    finalizerExecutionDebounce: "100 millis",
 }
-const nonReactiveTags = [Tracer.ParentSpan] as const
+
 export const nonReactiveTags = [Tracer.ParentSpan] as const
 export const isComponent = (u: unknown): u is Component<{}, React.ReactNode, unknown, unknown> => Predicate.hasProperty(u, TypeId)
@@ -340,17 +355,51 @@ export declare namespace make {
 }
 /**
- * Creates an Effect-FC Component following the same overloads and pipeline style as `Effect.fn`.
+ * Creates an Effect-FC Component using the same overloads and pipeline composition style as `Effect.fn`.
 *
- * This is the **recommended** way to define components. It supports:
+ * This is the **recommended** approach for defining Effect-FC components. It provides comprehensive
- * - Generator syntax (yield* style) — most ergonomic and readable
+ * support for multiple component definition patterns:
 * - Direct Effect return (non-generator)
 * - Chained transformation functions (like Effect.fn pipelines)
 * - Optional tracing span with automatic `displayName`
 *
- * When you provide a `spanName` as the first argument, two things happen automatically:
+ * - **Generator syntax** (yield* style): Most ergonomic and readable approach for sequential operations
- * 1. A tracing span is created with that name (unless using `makeUntraced`)
+ * - **Direct Effect return**: For simple components that return an Effect directly
- * 2. The resulting React component gets `displayName = spanName`
+ * - **Chained transformation functions**: Enables Effect.fn-style pipelines for composable transformations
 * - **Automatic tracing**: Optional tracing span creation with automatic `displayName` assignment
 *
 * When a `spanName` string is provided, the following occurs automatically:
 * 1. A distributed tracing span is created with the specified name
 * 2. The resulting React component receives `displayName = spanName` for DevTools visibility
 *
 * @example
 * ```tsx
 * const MyComponent = Component.make("MyComponent")(function* (props: { count: number }) {
 *   const value = yield* someEffect
 *   return <div>{value}</div>
 * })
 * ```
 *
 * @example As an opaque type using class syntax
 * ```tsx
 * class MyComponent extends Component.make("MyComponent")(function* (props: { count: number }) {
 *   const value = yield* someEffect
 *   return <div>{value}</div>
 * }) {}
 * ```
 *
 * @example Without name
 * ```tsx
 * class MyComponent extends Component.make(function* (props: { count: number }) {
 *   const value = yield* someEffect
 *   return <div>{value}</div>
 * }) {}
 * ```
 *
 * @example Using pipeline
 * ```tsx
 * class MyComponent extends Component.make("MyComponent")(
 *   (props: { count: number }) => someEffect,
 *   Effect.map(value => <div>{value}</div>),
 * ) {}
 * ```
 */
 export const make: (
    & make.Gen
@@ -365,7 +414,7 @@ export const make: (
            Object.assign(function() {}, defaultOptions, {
                body: Effect.fn(spanNameOrBody as any, ...pipeables),
            }),
-            ComponentProto,
+            ComponentPrototype,
        )
    }
    else {
@@ -375,21 +424,56 @@ export const make: (
                body: Effect.fn(spanNameOrBody, spanOptions)(body, ...pipeables as []),
                displayName: spanNameOrBody,
            }),
-            ComponentProto,
+            ComponentPrototype,
        )
    }
 }
 /**
- * Same as `make`, but creates an **untraced** version — no automatic tracing span is created.
+ * Creates an Effect-FC Component without automatic distributed tracing.
 *
- * Follows the exact same API shape as `Effect.fnUntraced`.
+ * This function provides the same API surface as `make`, but does not create automatic tracing spans.
- * Useful for:
+ * It follows the exact same overload structure as `Effect.fnUntraced`.
 * - Components where you want full manual control over tracing
 * - Avoiding span noise in deeply nested UI
 *
- * When a string is provided as first argument, it is **only** used as the React component's `displayName`
+ * Use this variant when you need:
- * (no tracing span is created).
+ * - Full manual control over tracing instrumentation
 * - To reduce tracing overhead in deeply nested component hierarchies
 * - To avoid span noise in performance-sensitive applications
 *
 * When a `spanName` string is provided, it is used **exclusively** as the React component's
 * `displayName` for DevTools identification. No tracing span is created.
 *
 * @example
 * ```tsx
 * const MyComponent = Component.makeUntraced("MyComponent")(function* (props: { count: number }) {
 *   const value = yield* someEffect
 *   return <div>{value}</div>
 * })
 * ```
 *
 * @example As an opaque type using class syntax
 * ```tsx
 * class MyComponent extends Component.makeUntraced("MyComponent")(function* (props: { count: number }) {
 *   const value = yield* someEffect
 *   return <div>{value}</div>
 * }) {}
 * ```
 *
 * @example Without name
 * ```tsx
 * class MyComponent extends Component.makeUntraced(function* (props: { count: number }) {
 *   const value = yield* someEffect
 *   return <div>{value}</div>
 * }) {}
 * ```
 *
 * @example Using pipeline
 * ```tsx
 * class MyComponent extends Component.makeUntraced("MyComponent")(
 *   (props: { count: number }) => someEffect,
 *   Effect.map(value => <div>{value}</div>),
 * ) {}
 * ```
 */
 export const makeUntraced: (
    & make.Gen
@@ -401,52 +485,71 @@ export const makeUntraced: (
            Object.assign(function() {}, defaultOptions, {
                body: Effect.fnUntraced(spanNameOrBody as any, ...pipeables as []),
            }),
-            ComponentProto,
+            ComponentPrototype,
        )
        : (body: any, ...pipeables: any[]) => Object.setPrototypeOf(
            Object.assign(function() {}, defaultOptions, {
                body: Effect.fnUntraced(body, ...pipeables as []),
                displayName: spanNameOrBody,
            }),
-            ComponentProto,
+            ComponentPrototype,
        )
 )
 /**
- * Creates a new component with modified options while preserving original behavior.
+ * Creates a new component with modified configuration options while preserving all original behavior.
 *
 * This function allows you to customize component-level options such as finalizer execution strategy
 * and debounce timing.
 *
 * @example
 * ```tsx
 * const MyComponentWithCustomOptions = MyComponent.pipe(
 *   Component.withOptions({
 *     finalizerExecutionStrategy: ExecutionStrategy.parallel,
 *     finalizerExecutionDebounce: "50 millis"
 *   })
 * )
 * ```
 */
 export const withOptions: {
    <T extends Component<any, any, any, any>>(
-        options: Partial<Component.Options>
+        options: Partial<ComponentOptions>
    ): (self: T) => T
    <T extends Component<any, any, any, any>>(
        self: T,
-        options: Partial<Component.Options>,
+        options: Partial<ComponentOptions>,
    ): T
 } = Function.dual(2, <T extends Component<any, any, any, any>>(
    self: T,
-    options: Partial<Component.Options>,
+    options: Partial<ComponentOptions>,
 ): T => Object.setPrototypeOf(
    Object.assign(function() {}, self, options),
    Object.getPrototypeOf(self),
 ))
 /**
- * Wraps an Effect-FC `Component` and turns it into a regular React function component
+ * Wraps an Effect-FC Component and converts it into a standard React function component,
- * that serves as an **entrypoint** into an Effect-FC component hierarchy.
+ * serving as an **entrypoint** into an Effect-FC component hierarchy.
 *
- * This is the recommended way to connect Effect-FC components to the rest of your React app,
+ * This is how Effect-FC components are integrated with the broader React ecosystem,
- * especially when using routers (TanStack Router, React Router, etc.), lazy-loaded routes,
+ * particularly when:
- * or any place where a standard React component is expected.
+ * - Using client-side routers (TanStack Router, React Router, etc.)
 * - Implementing lazy-loaded or code-split routes
 * - Connecting to third-party libraries expecting standard React components
 * - Creating component boundaries between Effect-FC and non-Effect-FC code
 *
- * The runtime is obtained from the provided React Context, allowing you to:
+ * The Effect runtime is obtained from the provided React Context.
 * - Provide dependencies once at a high level
 * - Use the same runtime across an entire route tree or feature
 *
- * @example Using TanStack Router
+ * @param self    - The Effect-FC Component to be rendered as a standard React component
 * @param context - React Context providing the Effect Runtime for this component tree.
 *                  Create this using the `ReactRuntime` module.
 *
 * @example Integration with TanStack Router
 * ```tsx
- * // Main
+ * // Application root
 * export const runtime = ReactRuntime.make(Layer.empty)
 *
 * function App() {
 *   return (
 *     <ReactRuntime.Provider runtime={runtime}>
@@ -455,14 +558,12 @@ export const withOptions: {
 *   )
 * }
 *
- * // Route
+ * // Route definition
 * export const Route = createFileRoute("/")({
 *   component: Component.withRuntime(HomePage, runtime.context)
 * })
 * ```
 *
 * @param self    - The Effect-FC Component you want to render as a regular React component.
 * @param context - React Context that holds the Runtime to use for this component tree. See the `ReactRuntime` module to create one.
 */
 export const withRuntime: {
    <P extends {}, A extends React.ReactNode, E, R>(
@@ -477,15 +578,17 @@ export const withRuntime: {
    context: React.Context<Runtime.Runtime<R>>,
 ) => function WithRuntime(props: P) {
    return React.createElement(
-        Runtime.runSync(React.useContext(context))(self),
+        Runtime.runSync(React.useContext(context))(self.use),
        props,
    )
 })
 /**
- * Service that keeps track of scopes associated with React components
+ * Internal Effect service that maintains a registry of scopes associated with React component instances.
- * (used internally by the `useScope` hook).
+ *
 * This service is used internally by the `useScope` hook to manage the lifecycle of component scopes,
 * including tracking active scopes and coordinating their cleanup when components unmount or dependencies change.
 */
 export class ScopeMap extends Effect.Service<ScopeMap>()("@effect-fc/Component/ScopeMap", {
    effect: Effect.bind(Effect.Do, "ref", () => Ref.make(HashMap.empty<object, ScopeMap.Entry>()))
@@ -507,12 +610,21 @@ export declare namespace useScope {
 }
 /**
- * Hook that creates and manages a `Scope` for the current component instance.
+ * Effect hook that creates and manages a `Scope` for the current component instance.
 *
- * Automatically closes the scope whenever `deps` changes or the component unmounts.
+ * This hook establishes a new scope that is automatically closed when:
 * - The component unmounts
 * - The dependency array `deps` changes
 *
- * @param deps - dependency array like in `React.useEffect`
+ * The scope provides a resource management boundary for any Effects executed within the component,
- * @param options - finalizer execution control
+ * ensuring proper cleanup of resources and execution of finalizers.
 *
 * @param deps     - Dependency array following React.useEffect semantics. The scope is recreated
 *                   whenever any dependency changes.
 * @param options  - Configuration for finalizer execution behavior, including execution strategy
 *                   and debounce timing.
 *
 * @returns An Effect that produces a `Scope` for resource management
 */
 export const useScope = Effect.fnUntraced(function*(
    deps: React.DependencyList,
@@ -567,7 +679,23 @@ export const useScope = Effect.fnUntraced(function*(
 })
 /**
- * Runs an effect and returns its result only once on component mount.
+ * Effect hook that executes an Effect once when the component mounts and caches the result.
 *
 * This hook is useful for one-time initialization logic that should not be re-executed
 * when the component re-renders. The Effect is executed exactly once during the component's
 * initial mount, and the cached result is returned on all subsequent renders.
 *
 * @param f - A function that returns the Effect to execute on mount
 *
 * @returns An Effect that produces the cached result of the Effect
 *
 * @example
 * ```tsx
 * const MyComponent = Component.make(function*() {
 *   const initialData = yield* Component.useOnMount(() => getData)
 *   return <div>{initialData}</div>
 * })
 * ```
 */
 export const useOnMount = Effect.fnUntraced(function* <A, E, R>(
    f: () => Effect.Effect<A, E, R>
@@ -581,9 +709,33 @@ export declare namespace useOnChange {
 }
 /**
- * Runs an effect and returns its result whenever dependencies change.
+ * Effect hook that executes an Effect whenever dependencies change and caches the result.
 *
- * Provides its own `Scope` which closes whenever `deps` changes or the component unmounts.
+ * This hook combines the dependency-tracking behavior of React.useEffect with Effect caching.
 * The Effect is re-executed whenever any dependency in the `deps` array changes, and the result
 * is cached until the next dependency change.
 *
 * A dedicated scope is created for each dependency change, ensuring proper resource cleanup:
 * - The scope closes when dependencies change
 * - The scope closes when the component unmounts
 * - All finalizers are executed according to the configured execution strategy
 *
 * @param f       - A function that returns the Effect to execute
 * @param deps    - Dependency array following React.useEffect semantics
 * @param options - Configuration for scope and finalizer behavior
 *
 * @returns An Effect that produces the cached result of the Effect
 *
 * @example
 * ```tsx
 * const MyComponent = Component.make(function* (props: { userId: string }) {
 *   const userData = yield* Component.useOnChange(
 *     getUser(props.userId),
 *     [props.userId],
 *   )
 *   return <div>{userData.name}</div>
 * })
 * ```
 */
 export const useOnChange = Effect.fnUntraced(function* <A, E, R>(
    f: () => Effect.Effect<A, E, R>,
@@ -607,9 +759,36 @@ export declare namespace useReactEffect {
 }
 /**
- * Like `React.useEffect` but accepts an effect.
+ * Effect hook that provides Effect-based semantics for React.useEffect.
 *
- * Cleanup logic is handled through the `Scope` API rather than using imperative cleanup.
+ * This hook bridges React's useEffect with the Effect system, allowing you to use Effects
 * for React side effects while maintaining React's dependency tracking and lifecycle semantics.
 *
 * Unlike React.useEffect which uses imperative cleanup functions, this hook leverages the
 * Effect Scope API for resource management. Cleanup logic is expressed declaratively through
 * finalizers registered with the scope, providing better composability and error handling.
 *
 * @param f       - A function that returns an Effect to execute as a side effect
 * @param deps    - Optional dependency array following React.useEffect semantics.
 *                  If omitted, the effect runs after every render.
 * @param options - Configuration for finalizer execution mode (sync or fork) and strategy
 *
 * @returns An Effect that produces void
 *
 * @example
 * ```tsx
 * const MyComponent = Component.make(function* (props: { id: string }) {
 *   yield* Component.useReactEffect(
 *     () => getNotificationStreamForUser(props.id).pipe(
 *       Stream.unwrap,
 *       Stream.runForEach(notification => Console.log(`Notification received: ${ notification }`),
 *       Effect.forkScoped,
 *     ),
 *     [props.id],
 *   )
 *   return <div>Subscribed to notifications for {props.id}</div>
 * })
 * ```
 */
 export const useReactEffect = Effect.fnUntraced(function* <E, R>(
    f: () => Effect.Effect<void, E, R>,
@@ -648,9 +827,43 @@ export declare namespace useReactLayoutEffect {
 }
 /**
- * Like `React.useReactLayoutEffect` but accepts an effect.
+ * Effect hook that provides Effect-based semantics for React.useLayoutEffect.
 *
- * Cleanup logic is handled through the `Scope` API rather than using imperative cleanup.
+ * This hook is identical to `useReactEffect` but executes synchronously after DOM mutations
 * but before the browser paints, following React.useLayoutEffect semantics.
 *
 * Use this hook when you need to:
 * - Measure DOM elements (e.g., for layout calculations)
 * - Synchronously update state based on DOM measurements
 * - Avoid visual flicker from asynchronous updates
 *
 * Like `useReactEffect`, cleanup logic is handled through the Effect Scope API rather than
 * imperative cleanup functions, providing declarative and composable resource management.
 *
 * @param f       - A function that returns an Effect to execute as a layout side effect
 * @param deps    - Optional dependency array following React.useLayoutEffect semantics.
 *                  If omitted, the effect runs after every render.
 * @param options - Configuration for finalizer execution mode (sync or fork) and strategy
 *
 * @returns An Effect that produces void
 *
 * @example
 * ```tsx
 * const MyComponent = Component.make(function*() {
 *   const ref = React.useRef<HTMLDivElement>(null)
 *   yield* Component.useReactLayoutEffect(
 *     () => Effect.gen(function* () {
 *       const element = ref.current
 *       if (element) {
 *         const rect = element.getBoundingClientRect()
 *         yield* Console.log(`Element dimensions: ${ rect.width }x${ rect.height }`)
 *       }
 *     }),
 *     [],
 *   )
 *   return <div ref={ref}>Content</div>
 * })
 * ```
 */
 export const useReactLayoutEffect = Effect.fnUntraced(function* <E, R>(
    f: () => Effect.Effect<void, E, R>,
@@ -663,7 +876,23 @@ export const useReactLayoutEffect = Effect.fnUntraced(function* <E, R>(
 })
 /**
- * Get a synchronous run function for the current runtime context.
+ * Effect hook that provides a synchronous function to execute Effects within the current runtime context.
 *
 * This hook returns a function that can execute Effects synchronously, blocking until completion.
 * Use this when you need to run Effects from non-Effect code (e.g., event handlers, callbacks)
 * within a component.
 *
 * @returns An Effect that produces a function capable of synchronously executing Effects
 *
 * @example
 * ```tsx
 * const MyComponent = Component.make(function*() {
 *   const runSync = yield* Component.useRunSync<SomeService>() // Specify required services
 *   const runSync = yield* Component.useRunSync() // Or no service requirements
 *
 *   return <button onClick={() => runSync(someEffect)}>Click me</button>
 * })
 * ```
 */
 export const useRunSync = <R = never>(): Effect.Effect<
    <A, E = never>(effect: Effect.Effect<A, E, Scope.Scope | R>) => A,
@@ -672,7 +901,23 @@ export const useRunSync = <R = never>(): Effect.Effect<
 > => Effect.andThen(Effect.runtime(), Runtime.runSync)
 /**
- * Get a Promise-based run function for the current runtime context.
+ * Effect hook that provides an asynchronous function to execute Effects within the current runtime context.
 *
 * This hook returns a function that executes Effects asynchronously, returning a Promise that resolves
 * with the Effect's result. Use this when you need to run Effects from non-Effect code (e.g., event handlers,
 * async callbacks) and want to handle the result asynchronously.
 *
 * @returns An Effect that produces a function capable of asynchronously executing Effects
 *
 * @example
 * ```tsx
 * const MyComponent = Component.make(function*() {
 *   const runPromise = yield* Component.useRunPromise<SomeService>() // Specify required services
 *   const runPromise = yield* Component.useRunPromise() // Or no service requirements
 *
 *   return <button onClick={() => runPromise(someEffect)}>Click me</button>
 * })
 * ```
 */
 export const useRunPromise = <R = never>(): Effect.Effect<
    <A, E = never>(effect: Effect.Effect<A, E, Scope.Scope | R>) => Promise<A>,
@@ -681,7 +926,32 @@ export const useRunPromise = <R = never>(): Effect.Effect<
 > => Effect.andThen(Effect.runtime(), context => Runtime.runPromise(context))
 /**
- * Turns a function returning an effect into a memoized synchronous function.
+ * Effect hook that memoizes a function that returns an Effect, providing synchronous execution.
 *
 * This hook wraps a function that returns an Effect and returns a memoized version that:
 * - Executes the Effect synchronously when called
 * - Is memoized based on the provided dependency array
 * - Maintains referential equality across renders when dependencies don't change
 *
 * Use this to create stable callback references for event handlers and other scenarios
 * where you need to execute Effects synchronously from non-Effect code.
 *
 * @param f    - A function that accepts arguments and returns an Effect
 * @param deps - Dependency array. The memoized function is recreated when dependencies change.
 *
 * @returns An Effect that produces a memoized function with the same signature as `f`
 *
 * @example
 * ```tsx
 * const MyComponent = Component.make(function* (props: { onSave: (data: Data) => void }) {
 *   const handleSave = yield* Component.useCallbackSync(
 *     (data: Data) => Effect.sync(() => props.onSave(data)),
 *     [props.onSave],
 *   )
 *
 *   return <button onClick={() => handleSave(myData)}>Save</button>
 * })
 * ```
 */
 export const useCallbackSync = Effect.fnUntraced(function* <Args extends unknown[], A, E, R>(
    f: (...args: Args) => Effect.Effect<A, E, R>,
@@ -696,7 +966,32 @@ export const useCallbackSync = Effect.fnUntraced(function* <Args extends unknown
 })
 /**
- * Turns a function returning an effect into a memoized Promise-based asynchronous function.
+ * Effect hook that memoizes a function that returns an Effect, providing asynchronous execution.
 *
 * This hook wraps a function that returns an Effect and returns a memoized version that:
 * - Executes the Effect asynchronously when called, returning a Promise
 * - Is memoized based on the provided dependency array
 * - Maintains referential equality across renders when dependencies don't change
 *
 * Use this to create stable callback references for async event handlers and other scenarios
 * where you need to execute Effects asynchronously from non-Effect code.
 *
 * @param f    - A function that accepts arguments and returns an Effect
 * @param deps - Dependency array. The memoized function is recreated when dependencies change.
 *
 * @returns An Effect that produces a memoized function that returns a Promise
 *
 * @example
 * ```tsx
 * const MyComponent = Component.make(function* (props: { onSave: (data: Data) => void }) {
 *   const handleSave = yield* Component.useCallbackPromise(
 *     (data: Data) => Effect.promise(() => props.onSave(data)),
 *     [props.onSave],
 *   )
 *
 *   return <button onClick={() => handleSave(myData)}>Save</button>
 * })
 * ```
 */
 export const useCallbackPromise = Effect.fnUntraced(function* <Args extends unknown[], A, E, R>(
    f: (...args: Args) => Effect.Effect<A, E, R>,
@@ -715,16 +1010,70 @@ export declare namespace useContext {
 }
 /**
- * Hook that constructs a layer and returns the created context.
+ * Effect hook that constructs an Effect Layer and returns the resulting context.
 *
- * The layer gets reconstructed everytime `layer` changes, so make sure its value is stable.
+ * This hook creates a managed runtime from the provided layer and returns the context it produces.
 * The layer is reconstructed whenever its value changes, so ensure the layer reference is stable
 * (typically by memoizing it or defining it outside the component).
 *
- * Building a layer containing asynchronous effects require the component calling this hook to be made async using `Async.async`.
+ * The hook automatically manages the layer's lifecycle:
 * - The layer is built when the component mounts or when the layer reference changes
 * - Resources are properly released when the component unmounts or dependencies change
 * - Finalizers are executed according to the configured execution strategy
 *
 * @param layer   - The Effect Layer to construct. Should be a stable reference to avoid unnecessary
 *                  reconstruction. Consider memoizing with React.useMemo if defined inline.
 * @param options - Configuration for scope and finalizer behavior
 *
 * @returns An Effect that produces the context created by the layer
 *
 * @throws If the layer contains asynchronous effects, the component must be wrapped with `Async.async`
 *
 * @example
 * ```tsx
 * const MyLayer = Layer.succeed(MyService, new MyServiceImpl())
 * const MyComponent = Component.make(function*() {
 *   const context = yield* Component.useContextFromLayer(MyLayer)
 *   const Sub = yield* SubComponent.use.pipe(
 *     Effect.provide(context)
 *   )
 *
 *   return <Sub />
 * })
 * ```
 *
 * @example With memoized layer
 * ```tsx
 * const MyComponent = Component.make(function*(props: { id: string })) {
 *   const context = yield* Component.useContextFromLayer(
 *     React.useMemo(() => Layer.succeed(MyService, new MyServiceImpl(props.id)), [props.id])
 *   )
 *   const Sub = yield* SubComponent.use.pipe(
 *     Effect.provide(context)
 *   )
 *
 *   return <Sub />
 * })
 * ```
 *
 * @example With async layer
 * ```tsx
 * const MyAsyncLayer = Layer.effect(MyService, someAsyncEffect)
 * const MyComponent = Component.make(function*() {
 *   const context = yield* Component.useContextFromLayer(MyAsyncLayer)
 *   const Sub = yield* SubComponent.use.pipe(
 *     Effect.provide(context)
 *   )
 *
 *   return <Sub />
 * }).pipe(
 *   Async.async // Required to handle async layer effects
 * )
 */
-export const useContext = <ROut, E, RIn>(
+export const useContextFromLayer = <ROut, E, RIn>(
    layer: Layer.Layer<ROut, E, RIn>,
    options?: useContext.Options,
-): Effect.Effect<Context.Context<ROut>, E, Exclude<RIn, Scope.Scope>> => useOnChange(() => Effect.context<RIn>().pipe(
+): Effect.Effect<Context.Context<ROut>, E, RIn | Scope.Scope> => useOnChange(() => Effect.context<RIn>().pipe(
    Effect.map(context => ManagedRuntime.make(Layer.provide(layer, Layer.succeedContext(context)))),
    Effect.tap(runtime => Effect.addFinalizer(() => runtime.disposeEffect)),
    Effect.andThen(runtime => runtime.runtimeEffect),
--- a/packages/effect-fc/src/Memoized.ts
+++ b/packages/effect-fc/src/Memoized.ts
@@ -1,24 +1,30 @@
 /** biome-ignore-all lint/complexity/useArrowFunction: necessary for class prototypes */
 import { type Equivalence, Function, Predicate } from "effect"
 import * as React from "react"
 import type * as Component from "./Component.js"
 export const TypeId: unique symbol = Symbol.for("@effect-fc/Memoized/Memoized")
 export type TypeId = typeof TypeId
-export interface Memoized<P> extends Memoized.Options<P> {
+export interface Memoized<P> extends MemoizedOptions<P> {
    readonly [TypeId]: TypeId
 }
-export namespace Memoized {
+export interface MemoizedOptions<P> {
-    export interface Options<P> {
+    readonly propsEquivalence?: Equivalence.Equivalence<P>
        readonly propsAreEqual?: Equivalence.Equivalence<P>
    }
 }
-const MemoizedProto = Object.freeze({
+export const MemoizedPrototype = Object.freeze({
-    [TypeId]: TypeId
+    [TypeId]: TypeId,
    transformFunctionComponent<P extends {}>(
        this: Memoized<P>,
        f: React.FC<P>,
    ) {
        return React.memo(f, this.propsEquivalence)
    },
 } as const)
@@ -29,22 +35,22 @@ export const memoized = <T extends Component.Component<any, any, any, any>>(
 ): T & Memoized<Component.Component.Props<T>> => Object.setPrototypeOf(
    Object.assign(function() {}, self),
    Object.freeze(Object.setPrototypeOf(
-        Object.assign({}, MemoizedProto),
+        Object.assign({}, MemoizedPrototype),
        Object.getPrototypeOf(self),
    )),
 )
 export const withOptions: {
    <T extends Component.Component<any, any, any, any> & Memoized<any>>(
-        options: Partial<Memoized.Options<Component.Component.Props<T>>>
+        options: Partial<MemoizedOptions<Component.Component.Props<T>>>
    ): (self: T) => T
    <T extends Component.Component<any, any, any, any> & Memoized<any>>(
        self: T,
-        options: Partial<Memoized.Options<Component.Component.Props<T>>>,
+        options: Partial<MemoizedOptions<Component.Component.Props<T>>>,
    ): T
 } = Function.dual(2, <T extends Component.Component<any, any, any, any> & Memoized<any>>(
    self: T,
-    options: Partial<Memoized.Options<Component.Component.Props<T>>>,
+    options: Partial<MemoizedOptions<Component.Component.Props<T>>>,
 ): T => Object.setPrototypeOf(
    Object.assign(function() {}, self, options),
    Object.getPrototypeOf(self),
--- a/packages/example/src/routes/dev/async-rendering.tsx
+++ b/packages/example/src/routes/dev/async-rendering.tsx
@@ -9,8 +9,8 @@ import { runtime } from "@/runtime"
 // Generator version
 const RouteComponent = Component.makeUntraced(function* AsyncRendering() {
-    const MemoizedAsyncComponentFC = yield* MemoizedAsyncComponent
+    const MemoizedAsyncComponentFC = yield* MemoizedAsyncComponent.use
-    const AsyncComponentFC = yield* AsyncComponent
+    const AsyncComponentFC = yield* AsyncComponent.use
    const [input, setInput] = React.useState("")
    return (
@@ -51,7 +51,7 @@ const RouteComponent = Component.makeUntraced(function* AsyncRendering() {
 class AsyncComponent extends Component.makeUntraced("AsyncComponent")(function*() {
-    const SubComponentFC = yield* SubComponent
+    const SubComponentFC = yield* SubComponent.use
    yield* Effect.sleep("500 millis") // Async operation
    // Cannot use React hooks after the async operation
--- a/packages/example/src/routes/dev/context.tsx
+++ b/packages/example/src/routes/dev/context.tsx
@@ -23,7 +23,7 @@ const SubComponent = Component.makeUntraced("SubComponent")(function*() {
 const ContextView = Component.makeUntraced("ContextView")(function*() {
    const [serviceValue, setServiceValue] = React.useState("test")
    const SubServiceLayer = React.useMemo(() => SubService.Default(serviceValue), [serviceValue])
-    const SubComponentFC = yield* Effect.provide(SubComponent, yield* Component.useContext(SubServiceLayer))
+    const SubComponentFC = yield* Effect.provide(SubComponent.use, yield* Component.useContextFromLayer(SubServiceLayer))
    return (
        <Container>
--- a/packages/example/src/routes/dev/memo.tsx
+++ b/packages/example/src/routes/dev/memo.tsx
@@ -17,8 +17,8 @@ const RouteComponent = Component.makeUntraced("RouteComponent")(function*() {
                onChange={e => setValue(e.target.value)}
            />
-            {yield* Effect.map(SubComponent, FC => <FC />)}
+            {yield* Effect.map(SubComponent.use, FC => <FC />)}
-            {yield* Effect.map(MemoizedSubComponent, FC => <FC />)}
+            {yield* Effect.map(MemoizedSubComponent.use, FC => <FC />)}
        </Flex>
    )
 }).pipe(
--- a/packages/example/src/routes/form.tsx
+++ b/packages/example/src/routes/form.tsx
@@ -70,7 +70,7 @@ class RegisterFormView extends Component.makeUntraced("RegisterFormView")(functi
    ])
    const runPromise = yield* Component.useRunPromise()
-    const TextFieldFormInputFC = yield* TextFieldFormInput
+    const TextFieldFormInputFC = yield* TextFieldFormInput.use
    yield* Component.useOnMount(() => Effect.gen(function*() {
        yield* Effect.addFinalizer(() => Console.log("RegisterFormView unmounted"))
@@ -117,8 +117,8 @@ class RegisterFormView extends Component.makeUntraced("RegisterFormView")(functi
 const RegisterPage = Component.makeUntraced("RegisterPage")(function*() {
    const RegisterFormViewFC = yield* Effect.provide(
-        RegisterFormView,
+        RegisterFormView.use,
-        yield* Component.useContext(RegisterForm.Default),
+        yield* Component.useContextFromLayer(RegisterForm.Default),
    )
    return <RegisterFormViewFC />
--- a/packages/example/src/routes/index.tsx
+++ b/packages/example/src/routes/index.tsx
@@ -10,8 +10,8 @@ const TodosStateLive = TodosState.Default("todos")
 const Index = Component.makeUntraced("Index")(function*() {
    const TodosFC = yield* Effect.provide(
-        Todos,
+        Todos.use,
-        yield* Component.useContext(TodosStateLive),
+        yield* Component.useContextFromLayer(TodosStateLive),
    )
    return <TodosFC />
--- a/packages/example/src/todo/Todo.tsx
+++ b/packages/example/src/todo/Todo.tsx
@@ -83,7 +83,7 @@ export class Todo extends Component.makeUntraced("Todo")(function*(props: TodoPr
    const runSync = yield* Component.useRunSync()
    const runPromise = yield* Component.useRunPromise<DateTime.CurrentTimeZone>()
-    const TextFieldFormInputFC = yield* TextFieldFormInput
+    const TextFieldFormInputFC = yield* TextFieldFormInput.use
    return (
--- a/packages/example/src/todo/Todos.tsx
+++ b/packages/example/src/todo/Todos.tsx
@@ -14,7 +14,7 @@ export class Todos extends Component.makeUntraced("Todos")(function*() {
        Effect.addFinalizer(() => Console.log("Todos unmounted")),
    ))
-    const TodoFC = yield* Todo
+    const TodoFC = yield* Todo.use
    return (
        <Container>
Author	SHA1	Message	Date
Renovate Bot	11c10f7142	Update dependency @effect/language-service to ^0.77.0 All checks were successful Lint / lint (push) Successful in 12s Details Test build / test-build (pull_request) Successful in 18s Details	2026-02-27 12:01:47 +00:00
Julien Valverdé	8e81ec85de	Fix All checks were successful Lint / lint (push) Successful in 12s Details	2026-02-27 10:49:54 +01:00
Julien Valverdé	97246845da	useContext -> useContextFromLayer All checks were successful Lint / lint (push) Successful in 12s Details	2026-02-27 10:45:08 +01:00
Julien Valverdé	2c78b17f52	Update comments Some checks failed Lint / lint (push) Failing after 1m4s Details	2026-02-27 10:16:52 +01:00
Julien Valverdé	6c14495693	Improve comments All checks were successful Lint / lint (push) Successful in 13s Details	2026-02-25 22:33:18 +01:00
Julien Valverdé	a73da25b8c	Fix All checks were successful Lint / lint (push) Successful in 12s Details	2026-02-25 03:18:24 +01:00
Julien Valverdé	d0bc4e4903	Refactor Component All checks were successful Lint / lint (push) Successful in 43s Details	2026-02-25 03:09:51 +01:00
Renovate Bot	0ae55bd02c	Update dependency @effect/language-service to ^0.75.0 (#34 ) All checks were successful Lint / lint (push) Successful in 14s Details This PR contains the following updates: \| Package \| Change \| [Age](https://docs.renovatebot.com/merge-confidence/) \| [Confidence](https://docs.renovatebot.com/merge-confidence/) \| \|---\|---\|---\|---\| \| [@effect/language-service](https://github.com/Effect-TS/language-service) \| [`^0.72.0` → `^0.75.0`](https://renovatebot.com/diffs/npm/@effect%2flanguage-service/0.72.1/0.75.1) \| ![age](https://developer.mend.io/api/mc/badges/age/npm/@effect%2flanguage-service/0.75.1?slim=true) \| ![confidence](https://developer.mend.io/api/mc/badges/confidence/npm/@effect%2flanguage-service/0.72.1/0.75.1?slim=true) \| --- ### Release Notes <details> <summary>Effect-TS/language-service (@effect/language-service)</summary> ### [`v0.75.1`](https://github.com/Effect-TS/language-service/releases/tag/%40effect/language-service%400.75.1) [Compare Source](https://github.com/Effect-TS/language-service/compare/@effect/language-service@0.75.0...@effect/language-service@0.75.1) ##### Patch Changes - [#647](https://github.com/Effect-TS/language-service/pull/647) [`489e3f0`](`489e3f0572`) Thanks [@mattiamanzati](https://github.com/mattiamanzati)! - Expose diagnostic quick fixes as refactoring actions to work around TypeScript's limited quick fix handling in some contexts - [#650](https://github.com/Effect-TS/language-service/pull/650) [`6f568cf`](`6f568cf37a`) Thanks [@mattiamanzati](https://github.com/mattiamanzati)! - Fix TypeParser to skip types with generic call signatures. When parsing covariant, contravariant, or invariant types, signatures with type parameters are now correctly rejected instead of being treated as concrete types. - [#649](https://github.com/Effect-TS/language-service/pull/649) [`5858fd1`](`5858fd1d87`) Thanks [@mattiamanzati](https://github.com/mattiamanzati)! - Performance improvements: replace `Nano.gen` with `Nano.fn` named functions across diagnostics, refactors, and code generation modules for better performance tracking and reduced runtime overhead. Add conditional `debugPerformance` flag to avoid unnecessary timing collection when not debugging. ### [`v0.75.0`](https://github.com/Effect-TS/language-service/releases/tag/%40effect/language-service%400.75.0) [Compare Source](https://github.com/Effect-TS/language-service/compare/@effect/language-service@0.74.0...@effect/language-service@0.75.0) ##### Minor Changes - [#645](https://github.com/Effect-TS/language-service/pull/645) [`a8a7d33`](`a8a7d33f3a`) Thanks [@mattiamanzati](https://github.com/mattiamanzati)! - Add `ServiceMap.Service` class completion for Effect v4, and fix Schema class completions for v4 (`TaggedErrorClass`, `TaggedClass` now available, `ErrorClass` fully-qualified form fixed, `RequestClass` removed) ### [`v0.74.0`](https://github.com/Effect-TS/language-service/releases/tag/%40effect/language-service%400.74.0) [Compare Source](https://github.com/Effect-TS/language-service/compare/@effect/language-service@0.73.1...@effect/language-service@0.74.0) ##### Minor Changes - [#641](https://github.com/Effect-TS/language-service/pull/641) [`693e5a5`](`693e5a5ef2`) Thanks [@mattiamanzati](https://github.com/mattiamanzati)! - Added Effect v4 support for diagnostics, refactors, and piping features. Diagnostics: - `multipleEffectProvide`: Warns when multiple `Effect.provide` calls are chained, suggesting consolidation - `strictEffectProvide`: Warns when using `Effect.provide` with Layer outside of application entry points - `missingLayerContext`: Detects missing Layer context requirements - `deterministicKeys`: Extended to support `ServiceMap.Service` patterns - `leakingRequirements`: Extended to detect leaking requirements in ServiceMap services - `schemaSyncInEffect`: Updated with v4-specific method mappings (e.g., `decodeSync` -> `decodeEffect`) Refactors: - `layerMagic`: Automatically compose and build layers based on service dependencies - `structuralTypeToSchema`: Convert TypeScript interfaces and type aliases to Effect Schema classes - `makeSchemaOpaque`: Enhanced for v4 with support for `Codec`, `DecodingServices`, and `EncodingServices` types - `typeToEffectSchema`: Enhanced to support Effect v4 schema patterns Piping: - Added pipe transformation support for Effect v4 including `Effect.fn`, nested pipes, and function call conversions ##### Patch Changes - [#643](https://github.com/Effect-TS/language-service/pull/643) [`68f6d12`](`68f6d120ad`) Thanks [@mattiamanzati](https://github.com/mattiamanzati)! - Disable `schemaUnionOfLiterals` diagnostic for Effect v4, as `Schema.Union` of multiple `Schema.Literal` calls is no longer applicable in v4. ### [`v0.73.1`](https://github.com/Effect-TS/language-service/releases/tag/%40effect/language-service%400.73.1) [Compare Source](https://github.com/Effect-TS/language-service/compare/@effect/language-service@0.73.0...@effect/language-service@0.73.1) ##### Patch Changes - [#639](https://github.com/Effect-TS/language-service/pull/639) [`ff72045`](`ff72045531`) Thanks [@mattiamanzati](https://github.com/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`](https://github.com/Effect-TS/language-service/releases/tag/%40effect/language-service%400.73.0) [Compare Source](https://github.com/Effect-TS/language-service/compare/@effect/language-service@0.72.1...@effect/language-service@0.73.0) ##### Minor Changes - [#637](https://github.com/Effect-TS/language-service/pull/637) [`616c2cc`](`616c2cc21c`) Thanks [@mattiamanzati](https://github.com/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 </details> --- ### Configuration 📅 Schedule: 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. 🔕 Ignore*: Close this PR and you won't be reminded about this update again. --- - [ ] <!-- rebase-check -->If you want to rebase/retry this PR, check this box --- This PR has been generated by [Renovate Bot](https://github.com/renovatebot/renovate). <!--renovate-debug:eyJjcmVhdGVkSW5WZXIiOiI0My4zLjQiLCJ1cGRhdGVkSW5WZXIiOiI0My4yNy4wIiwidGFyZ2V0QnJhbmNoIjoibmV4dCIsImxhYmVscyI6W119--> Reviewed-on: #34 Co-authored-by: Renovate Bot <renovate-bot@valverde.cloud> Co-committed-by: Renovate Bot <renovate-bot@valverde.cloud>	2026-02-23 23:32:07 +01:00
Julien Valverdé	bb044e766d	Fix README All checks were successful Lint / lint (push) Successful in 58s Details	2026-01-23 01:55:10 +01:00