@effect/language-service 0.78.0 → 0.80.0

package/cli.js

@@ -25719,7 +25719,7 @@ var runWith2 = (command, config) => {
 // package.json
 var package_default = {
   name: "@effect/language-service",
-  version: "0.78.0",
+  version: "0.80.0",
   publishConfig: {
     access: "public",
     directory: "dist"
@@ -25747,15 +25747,17 @@ var package_default = {
   ],
   scripts: {
     build: "tsup",
+    codegen: "node --import tsx ./scripts/codegen.ts",
     dev: "tsup --watch",
     clean: "rimraf dist build .tsbuildinfo",
     lint: "eslint src test",
     "lint-fix": "eslint src test --fix",
     check: "tsc -b tsconfig.json",
+    "check:codegen": "node --import tsx ./scripts/codegen.ts --check",
     circular: "madge --extensions ts --circular --no-color --no-spinner --warning src",
     test: "vitest",
     "test-update": "vitest --update",
-    "test-patch": "pnpm clean && pnpm build && pnpm effect-language-service unpatch && pnpm effect-language-service patch && pnpm check",
+    "test-patch": "pnpm clean && pnpm build && node dist/cli.js unpatch && node dist/cli.js patch && pnpm check",
     coverage: "vitest run --coverage",
     perf: "tsx test/perf.ts"
   },
@@ -27527,10 +27529,151 @@ var defaults = {
   extendedKeyDetection: false,
   ignoreEffectWarningsInTscExitCode: false,
   ignoreEffectSuggestionsInTscExitCode: true,
+  ignoreEffectErrorsInTscExitCode: false,
   pipeableMinArgCount: 2,
   effectFn: ["span"],
   layerGraphFollowDepth: 0,
-  mermaidProvider: "mermaid.live"
+  mermaidProvider: "mermaid.live",
+  skipDisabledOptimization: false
+};
+var booleanSchema = (description, defaultValue) => ({
+  type: "boolean",
+  description,
+  default: defaultValue
+});
+var stringArraySchema = (description, defaultValue) => ({
+  type: "array",
+  description,
+  default: defaultValue,
+  items: { type: "string" }
+});
+var stringEnumSchema = (description, values2, defaultValue) => ({
+  type: "string",
+  description,
+  enum: values2,
+  default: defaultValue
+});
+var languageServicePluginAdditionalPropertiesJsonSchema = {
+  refactors: booleanSchema("Controls Effect refactors.", defaults.refactors),
+  diagnostics: booleanSchema("Controls Effect diagnostics.", defaults.diagnostics),
+  diagnosticsName: booleanSchema(
+    "Controls whether to include the rule name in diagnostic messages.",
+    defaults.diagnosticsName
+  ),
+  missingDiagnosticNextLine: stringEnumSchema(
+    "Controls the severity of warnings for unused @effect-diagnostics-next-line comments.",
+    ["off", "error", "warning", "message", "suggestion"],
+    defaults.missingDiagnosticNextLine
+  ),
+  includeSuggestionsInTsc: booleanSchema(
+    "When patch mode is enabled, reports suggestion diagnostics as messages in TSC with a [suggestion] prefix.",
+    defaults.includeSuggestionsInTsc
+  ),
+  ignoreEffectWarningsInTscExitCode: booleanSchema(
+    "When enabled, Effect warnings do not affect the patched tsc exit code.",
+    defaults.ignoreEffectWarningsInTscExitCode
+  ),
+  ignoreEffectErrorsInTscExitCode: booleanSchema(
+    "When enabled, Effect errors do not affect the patched tsc exit code.",
+    defaults.ignoreEffectErrorsInTscExitCode
+  ),
+  ignoreEffectSuggestionsInTscExitCode: booleanSchema(
+    "When enabled, Effect suggestions do not affect the patched tsc exit code.",
+    defaults.ignoreEffectSuggestionsInTscExitCode
+  ),
+  quickinfoEffectParameters: stringEnumSchema(
+    "Controls when Effect quickinfo should include full type parameters.",
+    ["always", "never", "whentruncated"],
+    defaults.quickinfoEffectParameters
+  ),
+  quickinfo: booleanSchema("Controls Effect quickinfo.", defaults.quickinfo),
+  quickinfoMaximumLength: {
+    type: "number",
+    description: "Controls the maximum quickinfo length. Use -1 to disable truncation.",
+    default: defaults.quickinfoMaximumLength
+  },
+  keyPatterns: {
+    type: "array",
+    description: "Configures key patterns used for generated Effect service and error keys.",
+    default: defaults.keyPatterns,
+    items: {
+      type: "object",
+      properties: {
+        target: stringEnumSchema("The key builder target.", ["service", "error", "custom"], "service"),
+        pattern: stringEnumSchema(
+          "The key generation pattern.",
+          ["package-identifier", "default", "default-hashed"],
+          "default"
+        ),
+        skipLeadingPath: stringArraySchema("Path prefixes to strip before generating keys.", ["src/"])
+      }
+    }
+  },
+  extendedKeyDetection: booleanSchema(
+    "Enables extended heuristics when detecting key sources.",
+    defaults.extendedKeyDetection
+  ),
+  completions: booleanSchema("Controls Effect completions.", defaults.completions),
+  goto: booleanSchema("Controls Effect goto references support.", defaults.goto),
+  inlays: booleanSchema("Controls Effect inlay hints.", defaults.inlays),
+  allowedDuplicatedPackages: stringArraySchema(
+    "Package names that are allowed to duplicate Effect as a peer dependency.",
+    defaults.allowedDuplicatedPackages
+  ),
+  namespaceImportPackages: stringArraySchema(
+    "Package names that should prefer namespace imports.",
+    defaults.namespaceImportPackages
+  ),
+  topLevelNamedReexports: stringEnumSchema(
+    "For namespaceImportPackages, controls how top-level named re-exports are handled.",
+    ["ignore", "follow"],
+    defaults.topLevelNamedReexports
+  ),
+  barrelImportPackages: stringArraySchema(
+    "Package names that should prefer imports from their top-level barrel file.",
+    defaults.barrelImportPackages
+  ),
+  importAliases: {
+    type: "object",
+    description: "Custom aliases to use for imported identifiers.",
+    default: defaults.importAliases,
+    additionalProperties: {
+      type: "string"
+    }
+  },
+  renames: booleanSchema("Controls Effect rename helpers.", defaults.renames),
+  noExternal: booleanSchema(
+    "Disables features that link to external websites.",
+    defaults.noExternal
+  ),
+  pipeableMinArgCount: {
+    type: "number",
+    description: "Minimum argument count required before pipeable suggestions are emitted.",
+    default: defaults.pipeableMinArgCount
+  },
+  effectFn: {
+    type: "array",
+    description: "Configures which Effect.fn variants should be suggested.",
+    default: defaults.effectFn,
+    items: {
+      type: "string",
+      enum: ["untraced", "span", "suggested-span", "inferred-span", "no-span"]
+    }
+  },
+  layerGraphFollowDepth: {
+    type: "number",
+    description: "Controls how deeply layer graph analysis follows dependencies.",
+    default: defaults.layerGraphFollowDepth
+  },
+  mermaidProvider: {
+    type: "string",
+    description: "Controls which Mermaid renderer is used for layer graphs.",
+    default: defaults.mermaidProvider
+  },
+  skipDisabledOptimization: booleanSchema(
+    "When enabled, disabled diagnostics are still processed so comment-based overrides can be honored.",
+    defaults.skipDisabledOptimization
+  )
 };
 function parseKeyPatterns(patterns) {
   const result3 = [];
@@ -27554,6 +27697,7 @@ function parse4(config) {
     includeSuggestionsInTsc: isObject(config) && hasProperty(config, "includeSuggestionsInTsc") && isBoolean(config.includeSuggestionsInTsc) ? config.includeSuggestionsInTsc : defaults.includeSuggestionsInTsc,
     ignoreEffectWarningsInTscExitCode: isObject(config) && hasProperty(config, "ignoreEffectWarningsInTscExitCode") && isBoolean(config.ignoreEffectWarningsInTscExitCode) ? config.ignoreEffectWarningsInTscExitCode : defaults.ignoreEffectWarningsInTscExitCode,
     ignoreEffectSuggestionsInTscExitCode: isObject(config) && hasProperty(config, "ignoreEffectSuggestionsInTscExitCode") && isBoolean(config.ignoreEffectSuggestionsInTscExitCode) ? config.ignoreEffectSuggestionsInTscExitCode : defaults.ignoreEffectSuggestionsInTscExitCode,
+    ignoreEffectErrorsInTscExitCode: isObject(config) && hasProperty(config, "ignoreEffectErrorsInTscExitCode") && isBoolean(config.ignoreEffectErrorsInTscExitCode) ? config.ignoreEffectErrorsInTscExitCode : defaults.ignoreEffectErrorsInTscExitCode,
     quickinfo: isObject(config) && hasProperty(config, "quickinfo") && isBoolean(config.quickinfo) ? config.quickinfo : defaults.quickinfo,
     quickinfoEffectParameters: isObject(config) && hasProperty(config, "quickinfoEffectParameters") && isString(config.quickinfoEffectParameters) && ["always", "never", "whentruncated"].includes(config.quickinfoEffectParameters.toLowerCase()) ? config.quickinfoEffectParameters.toLowerCase() : defaults.quickinfoEffectParameters,
     quickinfoMaximumLength: isObject(config) && hasProperty(config, "quickinfoMaximumLength") && isNumber(config.quickinfoMaximumLength) ? config.quickinfoMaximumLength : defaults.quickinfoMaximumLength,
@@ -27574,7 +27718,8 @@ function parse4(config) {
       (_) => _.toLowerCase()
     ) : defaults.effectFn,
     layerGraphFollowDepth: isObject(config) && hasProperty(config, "layerGraphFollowDepth") && isNumber(config.layerGraphFollowDepth) ? config.layerGraphFollowDepth : defaults.layerGraphFollowDepth,
-    mermaidProvider: isObject(config) && hasProperty(config, "mermaidProvider") && isString(config.mermaidProvider) ? config.mermaidProvider : defaults.mermaidProvider
+    mermaidProvider: isObject(config) && hasProperty(config, "mermaidProvider") && isString(config.mermaidProvider) ? config.mermaidProvider : defaults.mermaidProvider,
+    skipDisabledOptimization: isObject(config) && hasProperty(config, "skipDisabledOptimization") && isBoolean(config.skipDisabledOptimization) ? config.skipDisabledOptimization : defaults.skipDisabledOptimization
   };
 }
 
@@ -27758,7 +27903,7 @@ var createDiagnosticExecutor = fn3("LSP.createCommentDirectivesProcessor")(
       if (skippedRules.indexOf(ruleNameLowered) > -1 || skippedRules.indexOf("*") > -1) {
         return { diagnostics: diagnostics3, codeFixes };
       }
-      if (defaultLevel === "off" && (lineOverrides[ruleNameLowered] || sectionOverrides[ruleNameLowered] || lineOverrides["*"] || sectionOverrides["*"] || []).length === 0) {
+      if (!pluginOptions.skipDisabledOptimization && defaultLevel === "off" && (lineOverrides[ruleNameLowered] || sectionOverrides[ruleNameLowered] || lineOverrides["*"] || sectionOverrides["*"] || []).length === 0) {
         return { diagnostics: diagnostics3, codeFixes };
       }
       const fixByDisableNextLine = (node) => ({
@@ -31656,6 +31801,8 @@ var anyUnknownInErrorContext = createDiagnostic({
   code: 28,
   description: "Detects 'any' or 'unknown' types in Effect error or requirements channels",
   severity: "off",
+  fixable: false,
+  supportedEffect: ["v3", "v4"],
   apply: fn3("anyUnknownInErrorContext.apply")(function* (sourceFile, report) {
     const ts = yield* service2(TypeScriptApi);
     const typeChecker = yield* service2(TypeCheckerApi);
@@ -31759,6 +31906,8 @@ var catchAllToMapError = createDiagnostic({
   code: 39,
   description: "Suggests using Effect.mapError instead of Effect.catchAll when the callback only wraps the error with Effect.fail",
   severity: "suggestion",
+  fixable: true,
+  supportedEffect: ["v3", "v4"],
   apply: fn3("catchAllToMapError.apply")(function* (sourceFile, report) {
     const ts = yield* service2(TypeScriptApi);
     const typeParser = yield* service2(TypeParser);
@@ -31856,6 +32005,8 @@ var catchUnfailableEffect = createDiagnostic({
   code: 2,
   description: "Warns when using error handling on Effects that never fail (error type is 'never')",
   severity: "suggestion",
+  fixable: false,
+  supportedEffect: ["v3", "v4"],
   apply: fn3("catchUnfailableEffect.apply")(function* (sourceFile, report) {
     const ts = yield* service2(TypeScriptApi);
     const typeParser = yield* service2(TypeParser);
@@ -31905,6 +32056,8 @@ var classSelfMismatch = createDiagnostic({
   code: 20,
   description: "Ensures Self type parameter matches the class name in Service/Tag/Schema classes",
   severity: "error",
+  fixable: true,
+  supportedEffect: ["v3", "v4"],
   apply: fn3("classSelfMismatch.apply")(function* (sourceFile, report) {
     const ts = yield* service2(TypeScriptApi);
     const typeParser = yield* service2(TypeParser);
@@ -32043,6 +32196,8 @@ var deterministicKeys = createDiagnostic({
   code: 25,
   description: "Enforces deterministic naming for service/tag/error identifiers based on class names",
   severity: "off",
+  fixable: true,
+  supportedEffect: ["v3", "v4"],
   apply: fn3("deterministicKeys.apply")(function* (sourceFile, report) {
     const ts = yield* service2(TypeScriptApi);
     const typeParser = yield* service2(TypeParser);
@@ -32160,6 +32315,8 @@ var duplicatePackage = createDiagnostic({
   code: 6,
   description: "Detects when multiple versions of the same Effect package are loaded",
   severity: "warning",
+  fixable: false,
+  supportedEffect: ["v3", "v4"],
   apply: fn3("duplicatePackage.apply")(function* (sourceFile, report) {
     const typeParser = yield* service2(TypeParser);
     const options = yield* service2(LanguageServicePluginOptions);
@@ -32189,6 +32346,8 @@ var effectFnIife = createDiagnostic({
   code: 46,
   description: "Effect.fn or Effect.fnUntraced is called as an IIFE (Immediately Invoked Function Expression). Use Effect.gen instead.",
   severity: "warning",
+  fixable: true,
+  supportedEffect: ["v3", "v4"],
   apply: fn3("effectFnIife.apply")(function* (sourceFile, report) {
     const ts = yield* service2(TypeScriptApi);
     const typeParser = yield* service2(TypeParser);
@@ -32291,6 +32450,8 @@ var effectFnOpportunity = createDiagnostic({
   code: 41,
   description: "Suggests using Effect.fn for functions that returns an Effect",
   severity: "suggestion",
+  fixable: true,
+  supportedEffect: ["v3", "v4"],
   apply: fn3("effectFnOpportunity.apply")(function* (sourceFile, report) {
     const ts = yield* service2(TypeScriptApi);
     const typeChecker = yield* service2(TypeCheckerApi);
@@ -32883,6 +33044,8 @@ var effectGenUsesAdapter = createDiagnostic({
   code: 23,
   description: "Warns when using the deprecated adapter parameter in Effect.gen",
   severity: "warning",
+  fixable: false,
+  supportedEffect: ["v3", "v4"],
   apply: fn3("effectGenUsesAdapter.apply")(function* (sourceFile, report) {
     const ts = yield* service2(TypeScriptApi);
     const typeParser = yield* service2(TypeParser);
@@ -32921,6 +33084,8 @@ var effectInFailure = createDiagnostic({
   code: 49,
   description: "Warns when an Effect is used inside an Effect failure channel",
   severity: "warning",
+  fixable: false,
+  supportedEffect: ["v3", "v4"],
   apply: fn3("effectInFailure.apply")(function* (sourceFile, report) {
     const ts = yield* service2(TypeScriptApi);
     const typeChecker = yield* service2(TypeCheckerApi);
@@ -32985,6 +33150,8 @@ var effectInVoidSuccess = createDiagnostic({
   code: 14,
   description: "Detects nested Effects in void success channels that may cause unexecuted effects",
   severity: "warning",
+  fixable: false,
+  supportedEffect: ["v3", "v4"],
   apply: fn3("effectInVoidSuccess.apply")(function* (sourceFile, report) {
     const ts = yield* service2(TypeScriptApi);
     const typeChecker = yield* service2(TypeCheckerApi);
@@ -33034,6 +33201,8 @@ var effectMapVoid = createDiagnostic({
   code: 40,
   description: "Suggests using Effect.asVoid instead of Effect.map(() => void 0), Effect.map(() => undefined), or Effect.map(() => {})",
   severity: "suggestion",
+  fixable: true,
+  supportedEffect: ["v3", "v4"],
   apply: fn3("effectMapVoid.apply")(function* (sourceFile, report) {
     const ts = yield* service2(TypeScriptApi);
     const typeParser = yield* service2(TypeParser);
@@ -33098,6 +33267,8 @@ var effectSucceedWithVoid = createDiagnostic({
   code: 47,
   description: "Suggests using Effect.void instead of Effect.succeed(undefined) or Effect.succeed(void 0)",
   severity: "suggestion",
+  fixable: true,
+  supportedEffect: ["v3", "v4"],
   apply: fn3("effectSucceedWithVoid.apply")(function* (sourceFile, report) {
     const ts = yield* service2(TypeScriptApi);
     const typeParser = yield* service2(TypeParser);
@@ -33143,12 +33314,66 @@ var effectSucceedWithVoid = createDiagnostic({
   })
 });
 
+// src/diagnostics/extendsNativeError.ts
+var extendsNativeError = createDiagnostic({
+  name: "extendsNativeError",
+  code: 50,
+  description: "Warns when a class directly extends the native Error class",
+  severity: "off",
+  fixable: false,
+  supportedEffect: ["v3", "v4"],
+  apply: fn3("extendsNativeError.apply")(function* (sourceFile, report) {
+    const ts = yield* service2(TypeScriptApi);
+    const typeChecker = yield* service2(TypeCheckerApi);
+    const errorSymbol = typeChecker.resolveName("Error", void 0, ts.SymbolFlags.Type, false);
+    if (!errorSymbol) return;
+    const nodeToVisit = [];
+    const appendNodeToVisit = (node) => {
+      nodeToVisit.push(node);
+      return void 0;
+    };
+    ts.forEachChild(sourceFile, appendNodeToVisit);
+    while (nodeToVisit.length > 0) {
+      const node = nodeToVisit.shift();
+      if (ts.isClassDeclaration(node) && node.heritageClauses) {
+        for (const clause of node.heritageClauses) {
+          if (clause.token === ts.SyntaxKind.ExtendsKeyword && clause.types.length > 0) {
+            const typeExpression = clause.types[0].expression;
+            const exprSymbol = typeChecker.getSymbolAtLocation(typeExpression);
+            const resolvedSymbol = exprSymbol && exprSymbol.flags & ts.SymbolFlags.Alias ? typeChecker.getAliasedSymbol(exprSymbol) : exprSymbol;
+            const isNativeError = resolvedSymbol === errorSymbol || (() => {
+              if (!resolvedSymbol || resolvedSymbol === errorSymbol) return false;
+              const exprType = typeChecker.getTypeAtLocation(typeExpression);
+              const constructSignatures = typeChecker.getSignaturesOfType(exprType, ts.SignatureKind.Construct);
+              if (constructSignatures.length > 0) {
+                const instanceType = typeChecker.getReturnTypeOfSignature(constructSignatures[0]);
+                return instanceType.symbol === errorSymbol;
+              }
+              return false;
+            })();
+            if (isNativeError) {
+              report({
+                location: node.name ?? typeExpression,
+                messageText: "Avoid extending the native 'Error' class directly. Consider using a tagged error (e.g. Data.TaggedError) to maintain type safety in the Effect failure channel.",
+                fixes: []
+              });
+            }
+          }
+        }
+      }
+      ts.forEachChild(node, appendNodeToVisit);
+    }
+  })
+});
+
 // src/diagnostics/floatingEffect.ts
 var floatingEffect = createDiagnostic({
   name: "floatingEffect",
   code: 3,
   description: "Ensures Effects are yielded or assigned to variables, not left floating",
   severity: "error",
+  fixable: false,
+  supportedEffect: ["v3", "v4"],
   apply: fn3("floatingEffect.apply")(function* (sourceFile, report) {
     const ts = yield* service2(TypeScriptApi);
     const typeChecker = yield* service2(TypeCheckerApi);
@@ -33200,6 +33425,8 @@ var genericEffectServices = createDiagnostic({
   code: 10,
   description: "Prevents services with type parameters that cannot be discriminated at runtime",
   severity: "warning",
+  fixable: false,
+  supportedEffect: ["v3", "v4"],
   apply: fn3("genericEffectServices.apply")(function* (sourceFile, report) {
     const ts = yield* service2(TypeScriptApi);
     const typeParser = yield* service2(TypeParser);
@@ -33247,6 +33474,8 @@ var globalErrorInEffectCatch = createDiagnostic({
   code: 36,
   description: "Warns when catch callbacks return global Error type instead of typed errors",
   severity: "warning",
+  fixable: false,
+  supportedEffect: ["v3", "v4"],
   apply: fn3("globalErrorInEffectCatch.apply")(function* (sourceFile, report) {
     const ts = yield* service2(TypeScriptApi);
     const typeParser = yield* service2(TypeParser);
@@ -33307,6 +33536,8 @@ var globalErrorInEffectFailure = createDiagnostic({
   code: 35,
   description: "Warns when the global Error type is used in an Effect failure channel",
   severity: "warning",
+  fixable: false,
+  supportedEffect: ["v3", "v4"],
   apply: fn3("globalErrorInEffectFailure.apply")(function* (sourceFile, report) {
     const ts = yield* service2(TypeScriptApi);
     const typeParser = yield* service2(TypeParser);
@@ -33360,6 +33591,8 @@ var importFromBarrel = createDiagnostic({
   code: 12,
   description: "Suggests importing from specific module paths instead of barrel exports",
   severity: "off",
+  fixable: true,
+  supportedEffect: ["v3", "v4"],
   apply: fn3("importFromBarrel.apply")(function* (sourceFile, report) {
     const languageServicePluginOptions = yield* service2(LanguageServicePluginOptions);
     if (languageServicePluginOptions.namespaceImportPackages.length === 0) return;
@@ -33500,6 +33733,8 @@ var instanceOfSchema = createDiagnostic({
   code: 45,
   description: "Suggests using Schema.is instead of instanceof for Effect Schema types",
   severity: "off",
+  fixable: true,
+  supportedEffect: ["v3", "v4"],
   apply: fn3("instanceOfSchema.apply")(function* (sourceFile, report) {
     const ts = yield* service2(TypeScriptApi);
     const typeParser = yield* service2(TypeParser);
@@ -33563,6 +33798,8 @@ var layerMergeAllWithDependencies = createDiagnostic({
   code: 37,
   description: "Detects interdependencies in Layer.mergeAll calls where one layer provides a service that another layer requires",
   severity: "warning",
+  fixable: true,
+  supportedEffect: ["v3", "v4"],
   apply: fn3("layerMergeAllWithDependencies.apply")(function* (sourceFile, report) {
     const ts = yield* service2(TypeScriptApi);
     const typeChecker = yield* service2(TypeCheckerApi);
@@ -33676,6 +33913,8 @@ var leakingRequirements = createDiagnostic({
   code: 8,
   description: "Detects implementation services leaked in service methods",
   severity: "suggestion",
+  fixable: false,
+  supportedEffect: ["v3", "v4"],
   apply: fn3("leakingRequirements.apply")(function* (sourceFile, report) {
     const ts = yield* service2(TypeScriptApi);
     const typeChecker = yield* service2(TypeCheckerApi);
@@ -33830,6 +34069,8 @@ var missedPipeableOpportunity = createDiagnostic({
   code: 26,
   description: "Enforces the use of pipeable style for nested function calls",
   severity: "off",
+  fixable: true,
+  supportedEffect: ["v3", "v4"],
   apply: fn3("missedPipeableOpportunity.apply")(function* (sourceFile, report) {
     const ts = yield* service2(TypeScriptApi);
     const typeChecker = yield* service2(TypeCheckerApi);
@@ -34010,6 +34251,8 @@ var missingEffectContext = createDiagnostic({
   code: 1,
   description: "Reports missing service requirements in Effect context channel",
   severity: "error",
+  fixable: false,
+  supportedEffect: ["v3", "v4"],
   apply: fn3("missingEffectContext.apply")(function* (sourceFile, report) {
     const typeChecker = yield* service2(TypeCheckerApi);
     const typeParser = yield* service2(TypeParser);
@@ -34059,6 +34302,8 @@ var missingEffectError = createDiagnostic({
   code: 1,
   description: "Reports missing error types in Effect error channel",
   severity: "error",
+  fixable: true,
+  supportedEffect: ["v3", "v4"],
   apply: fn3("missingEffectError.apply")(function* (sourceFile, report) {
     const ts = yield* service2(TypeScriptApi);
     const tsUtils = yield* service2(TypeScriptUtils);
@@ -34200,6 +34445,8 @@ var missingEffectServiceDependency = createDiagnostic({
   code: 22,
   description: "Checks that Effect.Service dependencies satisfy all required layer inputs",
   severity: "off",
+  fixable: false,
+  supportedEffect: ["v3"],
   apply: fn3("missingEffectServiceDependency.apply")(function* (sourceFile, report) {
     const ts = yield* service2(TypeScriptApi);
     const typeChecker = yield* service2(TypeCheckerApi);
@@ -34294,6 +34541,8 @@ var missingLayerContext = createDiagnostic({
   code: 38,
   description: "Reports missing service requirements in Layer context channel",
   severity: "error",
+  fixable: false,
+  supportedEffect: ["v3", "v4"],
   apply: fn3("missingLayerContext.apply")(function* (sourceFile, report) {
     const typeChecker = yield* service2(TypeCheckerApi);
     const typeParser = yield* service2(TypeParser);
@@ -34343,6 +34592,8 @@ var missingReturnYieldStar = createDiagnostic({
   code: 7,
   description: "Suggests using 'return yield*' for Effects with never success for better type narrowing",
   severity: "error",
+  fixable: true,
+  supportedEffect: ["v3", "v4"],
   apply: fn3("missingReturnYieldStar.apply")(function* (sourceFile, report) {
     const ts = yield* service2(TypeScriptApi);
     const typeCheckerUtils = yield* service2(TypeCheckerUtils);
@@ -34393,6 +34644,8 @@ var missingStarInYieldEffectGen = createDiagnostic({
   code: 4,
   description: "Enforces using 'yield*' instead of 'yield' when yielding Effects in generators",
   severity: "error",
+  fixable: true,
+  supportedEffect: ["v3", "v4"],
   apply: fn3("missingStarInYieldEffectGen.apply")(function* (sourceFile, report) {
     const ts = yield* service2(TypeScriptApi);
     const typeParser = yield* service2(TypeParser);
@@ -34468,6 +34721,8 @@ var multipleEffectProvide = createDiagnostic({
   code: 18,
   description: "Warns against chaining Effect.provide calls which can cause service lifecycle issues",
   severity: "warning",
+  fixable: true,
+  supportedEffect: ["v3", "v4"],
   apply: fn3("multipleEffectProvide.apply")(function* (sourceFile, report) {
     const ts = yield* service2(TypeScriptApi);
     const tsUtils = yield* service2(TypeScriptUtils);
@@ -34554,12 +34809,85 @@ var multipleEffectProvide = createDiagnostic({
   })
 });
 
+// src/diagnostics/nodeBuiltinImport.ts
+var moduleAlternativesV3 = /* @__PURE__ */ new Map([
+  ["fs", { alternative: "FileSystem", module: "fs", package: "@effect/platform" }],
+  ["node:fs", { alternative: "FileSystem", module: "fs", package: "@effect/platform" }],
+  ["fs/promises", { alternative: "FileSystem", module: "fs", package: "@effect/platform" }],
+  ["node:fs/promises", { alternative: "FileSystem", module: "fs", package: "@effect/platform" }],
+  ["path", { alternative: "Path", module: "path", package: "@effect/platform" }],
+  ["node:path", { alternative: "Path", module: "path", package: "@effect/platform" }],
+  ["path/posix", { alternative: "Path", module: "path", package: "@effect/platform" }],
+  ["node:path/posix", { alternative: "Path", module: "path", package: "@effect/platform" }],
+  ["path/win32", { alternative: "Path", module: "path", package: "@effect/platform" }],
+  ["node:path/win32", { alternative: "Path", module: "path", package: "@effect/platform" }],
+  ["child_process", { alternative: "CommandExecutor", module: "child_process", package: "@effect/platform" }],
+  ["node:child_process", { alternative: "CommandExecutor", module: "child_process", package: "@effect/platform" }]
+]);
+var moduleAlternativesV4 = /* @__PURE__ */ new Map([
+  ["fs", { alternative: "FileSystem", module: "fs", package: "effect" }],
+  ["node:fs", { alternative: "FileSystem", module: "fs", package: "effect" }],
+  ["fs/promises", { alternative: "FileSystem", module: "fs", package: "effect" }],
+  ["node:fs/promises", { alternative: "FileSystem", module: "fs", package: "effect" }],
+  ["path", { alternative: "Path", module: "path", package: "effect" }],
+  ["node:path", { alternative: "Path", module: "path", package: "effect" }],
+  ["path/posix", { alternative: "Path", module: "path", package: "effect" }],
+  ["node:path/posix", { alternative: "Path", module: "path", package: "effect" }],
+  ["path/win32", { alternative: "Path", module: "path", package: "effect" }],
+  ["node:path/win32", { alternative: "Path", module: "path", package: "effect" }],
+  ["child_process", { alternative: "ChildProcess", module: "child_process", package: "effect" }],
+  ["node:child_process", { alternative: "ChildProcess", module: "child_process", package: "effect" }]
+]);
+var nodeBuiltinImport = createDiagnostic({
+  name: "nodeBuiltinImport",
+  code: 52,
+  description: "Warns when importing Node.js built-in modules that have Effect-native counterparts",
+  severity: "off",
+  fixable: false,
+  supportedEffect: ["v3", "v4"],
+  apply: fn3("nodeBuiltinImport.apply")(function* (sourceFile, report) {
+    const ts = yield* service2(TypeScriptApi);
+    const typeParser = yield* service2(TypeParser);
+    const moduleAlternatives = typeParser.supportedEffect() === "v3" ? moduleAlternativesV3 : moduleAlternativesV4;
+    for (const statement of sourceFile.statements) {
+      if (ts.isImportDeclaration(statement) && ts.isStringLiteral(statement.moduleSpecifier)) {
+        const specifier = statement.moduleSpecifier.text;
+        const match9 = moduleAlternatives.get(specifier);
+        if (match9) {
+          report({
+            location: statement.moduleSpecifier,
+            messageText: `Prefer using ${match9.alternative} from ${match9.package} instead of the Node.js '${match9.module}' module.`,
+            fixes: []
+          });
+        }
+      } else if (ts.isVariableStatement(statement)) {
+        for (const decl of statement.declarationList.declarations) {
+          if (decl.initializer && ts.isCallExpression(decl.initializer) && ts.isIdentifier(decl.initializer.expression) && ts.idText(decl.initializer.expression) === "require" && decl.initializer.arguments.length === 1 && ts.isStringLiteral(decl.initializer.arguments[0])) {
+            const arg = decl.initializer.arguments[0];
+            const specifier = arg.text;
+            const match9 = moduleAlternatives.get(specifier);
+            if (match9) {
+              report({
+                location: arg,
+                messageText: `Prefer using ${match9.alternative} from ${match9.package} instead of the Node.js '${match9.module}' module.`,
+                fixes: []
+              });
+            }
+          }
+        }
+      }
+    }
+  })
+});
+
 // src/diagnostics/nonObjectEffectServiceType.ts
 var nonObjectEffectServiceType = createDiagnostic({
   name: "nonObjectEffectServiceType",
   code: 24,
   description: "Ensures Effect.Service types are objects, not primitives",
   severity: "error",
+  fixable: false,
+  supportedEffect: ["v3"],
   apply: fn3("nonObjectEffectServiceType.apply")(function* (sourceFile, report) {
     const ts = yield* service2(TypeScriptApi);
     const typeChecker = yield* service2(TypeCheckerApi);
@@ -35342,6 +35670,8 @@ var outdatedApi = createDiagnostic({
   code: 48,
   description: "Detects usage of APIs that have been removed or renamed in Effect v4",
   severity: "warning",
+  fixable: false,
+  supportedEffect: ["v4"],
   apply: fn3("outdatedApi.apply")(function* (sourceFile, report) {
     const typeParser = yield* service2(TypeParser);
     const ts = yield* service2(TypeScriptApi);
@@ -35409,6 +35739,8 @@ var outdatedEffectCodegen = createDiagnostic({
   code: 19,
   description: "Detects when generated code is outdated and needs to be regenerated",
   severity: "warning",
+  fixable: true,
+  supportedEffect: ["v3", "v4"],
   apply: fn3("outdatedEffectCodegen.apply")(function* (sourceFile, _report) {
     const codegensWithRanges = yield* getCodegensForSourceFile(codegens, sourceFile);
     for (const { codegen: codegen2, hash: hash2, range: range2 } of codegensWithRanges) {
@@ -35455,6 +35787,8 @@ var overriddenSchemaConstructor = createDiagnostic({
   code: 30,
   description: "Prevents overriding constructors in Schema classes which breaks decoding behavior",
   severity: "error",
+  fixable: true,
+  supportedEffect: ["v3", "v4"],
   apply: fn3("overriddenSchemaConstructor.apply")(function* (sourceFile, report) {
     const ts = yield* service2(TypeScriptApi);
     const typeParser = yield* service2(TypeParser);
@@ -35592,6 +35926,8 @@ var preferSchemaOverJson = createDiagnostic({
   code: 44,
   description: "Suggests using Effect Schema for JSON operations instead of JSON.parse/JSON.stringify which may throw",
   severity: "suggestion",
+  fixable: false,
+  supportedEffect: ["v3", "v4"],
   apply: fn3("preferSchemaOverJson.apply")(function* (sourceFile, report) {
     const ts = yield* service2(TypeScriptApi);
     const typeParser = yield* service2(TypeParser);
@@ -35702,6 +36038,8 @@ var redundantSchemaTagIdentifier = createDiagnostic({
   code: 42,
   description: "Suggests removing redundant identifier argument when it equals the tag value in Schema.TaggedClass/TaggedError/TaggedRequest",
   severity: "suggestion",
+  fixable: true,
+  supportedEffect: ["v3", "v4"],
   apply: fn3("redundantSchemaTagIdentifier.apply")(function* (sourceFile, report) {
     const ts = yield* service2(TypeScriptApi);
     const typeParser = yield* service2(TypeParser);
@@ -35752,6 +36090,8 @@ var returnEffectInGen = createDiagnostic({
   code: 11,
   description: "Warns when returning an Effect in a generator causes nested Effect<Effect<...>>",
   severity: "suggestion",
+  fixable: true,
+  supportedEffect: ["v3", "v4"],
   apply: fn3("returnEffectInGen.apply")(function* (sourceFile, report) {
     const ts = yield* service2(TypeScriptApi);
     const typeCheckerUtils = yield* service2(TypeCheckerUtils);
@@ -35821,6 +36161,8 @@ var runEffectInsideEffect = createDiagnostic({
   code: 32,
   description: "Suggests using Runtime methods instead of Effect.run* inside Effect contexts",
   severity: "suggestion",
+  fixable: true,
+  supportedEffect: ["v3"],
   apply: fn3("runEffectInsideEffect.apply")(function* (sourceFile, report) {
     const ts = yield* service2(TypeScriptApi);
     const typeParser = yield* service2(TypeParser);
@@ -35945,6 +36287,8 @@ var schemaStructWithTag = createDiagnostic({
   code: 34,
   description: "Suggests using Schema.TaggedStruct instead of Schema.Struct with _tag field",
   severity: "suggestion",
+  fixable: true,
+  supportedEffect: ["v3", "v4"],
   apply: fn3("schemaStructWithTag.apply")(function* (sourceFile, report) {
     const ts = yield* service2(TypeScriptApi);
     const typeParser = yield* service2(TypeParser);
@@ -36037,6 +36381,8 @@ var schemaSyncInEffect = createDiagnostic({
   code: 43,
   description: "Suggests using Effect-based Schema methods instead of sync methods inside Effect generators",
   severity: "suggestion",
+  fixable: false,
+  supportedEffect: ["v3", "v4"],
   apply: fn3("schemaSyncInEffect.apply")(function* (sourceFile, report) {
     const ts = yield* service2(TypeScriptApi);
     const typeParser = yield* service2(TypeParser);
@@ -36086,6 +36432,8 @@ var schemaUnionOfLiterals = createDiagnostic({
   code: 33,
   description: "Simplifies Schema.Union of multiple Schema.Literal calls into single Schema.Literal",
   severity: "off",
+  fixable: true,
+  supportedEffect: ["v3"],
   apply: fn3("schemaUnionOfLiterals.apply")(function* (sourceFile, report) {
     const ts = yield* service2(TypeScriptApi);
     const typeParser = yield* service2(TypeParser);
@@ -36161,6 +36509,8 @@ var scopeInLayerEffect = createDiagnostic({
   code: 13,
   description: "Suggests using Layer.scoped instead of Layer.effect when Scope is in requirements",
   severity: "warning",
+  fixable: true,
+  supportedEffect: ["v3"],
   apply: fn3("scopeInLayerEffect.apply")(function* (sourceFile, report) {
     const ts = yield* service2(TypeScriptApi);
     const tsUtils = yield* service2(TypeScriptUtils);
@@ -36250,12 +36600,91 @@ Consider using "scoped" instead to get rid of the scope in the requirements.`,
   })
 });
 
+// src/diagnostics/serviceNotAsClass.ts
+var serviceNotAsClass = createDiagnostic({
+  name: "serviceNotAsClass",
+  code: 51,
+  description: "Warns when ServiceMap.Service is used as a variable instead of a class declaration",
+  severity: "off",
+  fixable: true,
+  supportedEffect: ["v4"],
+  apply: fn3("serviceNotAsClass.apply")(function* (sourceFile, report) {
+    const ts = yield* service2(TypeScriptApi);
+    const typeParser = yield* service2(TypeParser);
+    if (typeParser.supportedEffect() === "v3") return;
+    const nodeToVisit = [];
+    const appendNodeToVisit = (node) => {
+      nodeToVisit.push(node);
+      return void 0;
+    };
+    ts.forEachChild(sourceFile, appendNodeToVisit);
+    while (nodeToVisit.length > 0) {
+      const node = nodeToVisit.shift();
+      ts.forEachChild(node, appendNodeToVisit);
+      if (!ts.isVariableDeclaration(node)) continue;
+      if (!node.initializer || !ts.isCallExpression(node.initializer)) continue;
+      const callExpr = node.initializer;
+      if (!callExpr.typeArguments || callExpr.typeArguments.length === 0) continue;
+      const typeArgs = callExpr.typeArguments;
+      const declList = node.parent;
+      if (!ts.isVariableDeclarationList(declList)) continue;
+      if (!(declList.flags & ts.NodeFlags.Const)) continue;
+      const isServiceMapService = yield* pipe(
+        typeParser.isNodeReferenceToServiceMapModuleApi("Service")(callExpr.expression),
+        orUndefined
+      );
+      if (!isServiceMapService) continue;
+      const variableName = ts.isIdentifier(node.name) ? ts.idText(node.name) : sourceFile.text.substring(ts.getTokenPosOfNode(node.name, sourceFile), node.name.end);
+      const variableStatement = declList.parent;
+      const argsText = callExpr.arguments.length > 0 ? callExpr.arguments.map((a) => sourceFile.text.substring(ts.getTokenPosOfNode(a, sourceFile), a.end)).join(", ") : "";
+      const shapeText = typeArgs.length > 0 ? typeArgs.map((t) => sourceFile.text.substring(ts.getTokenPosOfNode(t, sourceFile), t.end)).join(", ") : "Shape";
+      report({
+        location: callExpr,
+        messageText: `ServiceMap.Service should be used in a class declaration instead of as a variable. Use: class ${variableName} extends ServiceMap.Service<${variableName}, ${shapeText}>()("${argsText.replace(/['"]/g, "")}") {}`,
+        fixes: [{
+          fixName: "serviceNotAsClass",
+          description: `Convert to class declaration`,
+          apply: gen3(function* () {
+            const changeTracker = yield* service2(ChangeTracker);
+            const targetNode = ts.isVariableStatement(variableStatement) ? variableStatement : declList;
+            const innerCall = ts.factory.createCallExpression(
+              callExpr.expression,
+              [ts.factory.createTypeReferenceNode(variableName), ...typeArgs],
+              []
+            );
+            const outerCall = ts.factory.createCallExpression(
+              innerCall,
+              void 0,
+              [...callExpr.arguments]
+            );
+            const heritageClause = ts.factory.createHeritageClause(
+              ts.SyntaxKind.ExtendsKeyword,
+              [ts.factory.createExpressionWithTypeArguments(outerCall, void 0)]
+            );
+            const modifiers = ts.isVariableStatement(variableStatement) ? variableStatement.modifiers : void 0;
+            const classDeclaration = ts.factory.createClassDeclaration(
+              modifiers,
+              ts.isIdentifier(node.name) ? node.name : ts.factory.createIdentifier(variableName),
+              void 0,
+              [heritageClause],
+              []
+            );
+            changeTracker.replaceNode(sourceFile, targetNode, classDeclaration);
+          })
+        }]
+      });
+    }
+  })
+});
+
 // src/diagnostics/strictBooleanExpressions.ts
 var strictBooleanExpressions = createDiagnostic({
   name: "strictBooleanExpressions",
   code: 17,
   description: "Enforces boolean types in conditional expressions for type safety",
   severity: "off",
+  fixable: false,
+  supportedEffect: ["v3", "v4"],
   apply: fn3("strictBooleanExpressions.apply")(function* (sourceFile, report) {
     const ts = yield* service2(TypeScriptApi);
     const typeChecker = yield* service2(TypeCheckerApi);
@@ -36327,6 +36756,8 @@ var strictEffectProvide = createDiagnostic({
   code: 27,
   description: "Warns when using Effect.provide with layers outside of application entry points",
   severity: "off",
+  fixable: false,
+  supportedEffect: ["v3", "v4"],
   apply: fn3("strictEffectProvide.apply")(function* (sourceFile, report) {
     const ts = yield* service2(TypeScriptApi);
     const typeCheckerUtils = yield* service2(TypeCheckerUtils);
@@ -36378,6 +36809,8 @@ var tryCatchInEffectGen = createDiagnostic({
   code: 15,
   description: "Discourages try/catch in Effect generators in favor of Effect error handling",
   severity: "suggestion",
+  fixable: false,
+  supportedEffect: ["v3", "v4"],
   apply: fn3("tryCatchInEffectGen.apply")(function* (sourceFile, report) {
     const ts = yield* service2(TypeScriptApi);
     const typeParser = yield* service2(TypeParser);
@@ -36435,6 +36868,8 @@ var unknownInEffectCatch = createDiagnostic({
   code: 31,
   description: "Warns when catch callbacks return unknown instead of typed errors",
   severity: "warning",
+  fixable: false,
+  supportedEffect: ["v3", "v4"],
   apply: fn3("unknownInEffectCatch.apply")(function* (sourceFile, report) {
     const ts = yield* service2(TypeScriptApi);
     const typeParser = yield* service2(TypeParser);
@@ -36496,6 +36931,8 @@ var unnecessaryEffectGen = createDiagnostic({
   code: 5,
   description: "Suggests removing Effect.gen when it contains only a single return statement",
   severity: "suggestion",
+  fixable: true,
+  supportedEffect: ["v3", "v4"],
   apply: fn3("unnecessaryEffectGen.apply")(function* (sourceFile, report) {
     const ts = yield* service2(TypeScriptApi);
     const typeParser = yield* service2(TypeParser);
@@ -36540,6 +36977,8 @@ var unnecessaryFailYieldableError = createDiagnostic({
   code: 29,
   description: "Suggests yielding yieldable errors directly instead of wrapping with Effect.fail",
   severity: "suggestion",
+  fixable: true,
+  supportedEffect: ["v3", "v4"],
   apply: fn3("unnecessaryFailYieldableError.apply")(function* (sourceFile, report) {
     const ts = yield* service2(TypeScriptApi);
     const typeParser = yield* service2(TypeParser);
@@ -36599,6 +37038,8 @@ var unnecessaryPipe = createDiagnostic({
   code: 9,
   description: "Removes pipe calls with no arguments",
   severity: "suggestion",
+  fixable: true,
+  supportedEffect: ["v3", "v4"],
   apply: fn3("unnecessaryPipe.apply")(function* (sourceFile, report) {
     const ts = yield* service2(TypeScriptApi);
     const typeParser = yield* service2(TypeParser);
@@ -36645,6 +37086,8 @@ var unnecessaryPipeChain = createDiagnostic({
   code: 16,
   description: "Simplifies chained pipe calls into a single pipe call",
   severity: "suggestion",
+  fixable: true,
+  supportedEffect: ["v3", "v4"],
   apply: fn3("unnecessaryPipeChain.apply")(function* (sourceFile, report) {
     const ts = yield* service2(TypeScriptApi);
     const typeParser = yield* service2(TypeParser);
@@ -36720,6 +37163,8 @@ var unsupportedServiceAccessors = createDiagnostic({
   code: 21,
   description: "Warns about service accessors that need codegen due to generic/complex signatures",
   severity: "warning",
+  fixable: true,
+  supportedEffect: ["v3", "v4"],
   apply: fn3("unsupportedServiceAccessors.apply")(function* (sourceFile, report) {
     const ts = yield* service2(TypeScriptApi);
     const nodeToVisit = [];
@@ -36822,7 +37267,10 @@ var diagnostics = [
   effectFnOpportunity,
   redundantSchemaTagIdentifier,
   schemaSyncInEffect,
-  preferSchemaOverJson
+  preferSchemaOverJson,
+  extendsNativeError,
+  serviceNotAsClass,
+  nodeBuiltinImport
 ];
 
 // src/cli/diagnostics.ts
@@ -36836,6 +37284,11 @@ var DiagnosticsFoundError = class extends TaggedError2("DiagnosticsFoundError")
     return `Found ${this.errorsCount} errors, ${this.warningsCount} warnings and ${this.messagesCount} messages.`;
   }
 };
+var InvalidLspConfigError = class extends TaggedError2("InvalidLspConfigError") {
+  get message() {
+    return `Invalid JSON lsp config: ${this.lspconfig}`;
+  }
+};
 var categoryToSeverity = (category, tsInstance) => {
   switch (category) {
     case tsInstance.DiagnosticCategory.Error:
@@ -37031,9 +37484,15 @@ var diagnostics2 = Command_exports.make(
     progress: Flag_exports.boolean("progress").pipe(
       Flag_exports.withDefault(false),
       Flag_exports.withDescription("Show progress as files are checked (outputs to stderr)")
+    ),
+    lspconfig: Flag_exports.string("lspconfig").pipe(
+      Flag_exports.optional,
+      Flag_exports.withDescription(
+        `An optional inline JSON lsp config that replaces the current project lsp config. e.g. '{ "effectFn": ["untraced"] }'`
+      )
     )
   },
-  fn2("diagnostics")(function* ({ file: file4, format: format3, progress, project: project2, severity, strict }) {
+  fn2("diagnostics")(function* ({ file: file4, format: format3, lspconfig, progress, project: project2, severity, strict }) {
     const path4 = yield* Path;
     const severityFilter = parseSeverityFilter(severity);
     const state = {
@@ -37097,7 +37556,14 @@ var diagnostics2 = Command_exports.make(
           if (!program) continue;
           const sourceFile = program.getSourceFile(filePath);
           if (!sourceFile) continue;
-          const pluginConfig = extractEffectLspOptions(program.getCompilerOptions());
+          let pluginConfig = extractEffectLspOptions(program.getCompilerOptions());
+          if (isSome2(lspconfig)) {
+            try {
+              pluginConfig = { name: "@effect/language-service", ...JSON.parse(lspconfig.value) };
+            } catch {
+              return yield* new InvalidLspConfigError({ lspconfig: lspconfig.value });
+            }
+          }
           if (!pluginConfig) continue;
           const rawResults = pipe(
             getSemanticDiagnosticsWithCodeFixes(diagnostics, sourceFile),
@@ -37757,7 +38223,10 @@ var import_project_service3 = __toESM(require_dist3());
 var getLocationFromDeclaration = (declaration, tsInstance) => {
   const sourceFile = declaration.getSourceFile();
   if (!sourceFile) return void 0;
-  const { character, line } = tsInstance.getLineAndCharacterOfPosition(sourceFile, declaration.getStart());
+  const { character, line } = tsInstance.getLineAndCharacterOfPosition(
+    sourceFile,
+    tsInstance.getTokenPosOfNode(declaration, sourceFile)
+  );
   return {
     filePath: sourceFile.fileName,
     line: line + 1,
@@ -38359,7 +38828,8 @@ function getExpressionName(tsApi, expr) {
   if (tsApi.isCallExpression(expr)) {
     return getExpressionName(tsApi, expr.expression);
   }
-  const text2 = expr.getText().replace(/\s+/g, " ");
+  const sourceFile = expr.getSourceFile();
+  const text2 = sourceFile.text.substring(tsApi.getTokenPosOfNode(expr, sourceFile), expr.end).replace(/\s+/g, " ");
   return text2.length > 30 ? text2.slice(0, 27) + "..." : text2;
 }
 var collectLayerInfoByName = (sourceFile, layerName, selectedOutputIndices) => gen3(function* () {
@@ -39377,6 +39847,7 @@ var assess = (input) => gen2(function* () {
 });
 
 // src/cli/setup/changes.ts
+var TSCONFIG_SCHEMA_URL = "https://raw.githubusercontent.com/Effect-TS/language-service/refs/heads/main/schema.json";
 function emptyFileChangesResult() {
   return {
     codeActions: [],
@@ -39723,8 +40194,17 @@ var computeTsConfigChanges = (current, target, lspVersion) => {
     const fileChanges = textChanges.ChangeTracker.with(
       { host, formatContext, preferences },
       (tracker) => {
+        const schemaProperty = findPropertyInObject(ts, rootObj, "$schema");
         const pluginsProperty = findPropertyInObject(ts, compilerOptions, "plugins");
+        const schemaPropertyAssignment = ts.factory.createPropertyAssignment(
+          ts.factory.createStringLiteral("$schema"),
+          ts.factory.createStringLiteral(TSCONFIG_SCHEMA_URL)
+        );
         if (isNone2(lspVersion)) {
+          if (schemaProperty) {
+            descriptions.push("Remove $schema from tsconfig");
+            deleteNodeFromList(tracker, current.sourceFile, rootObj.properties, schemaProperty);
+          }
           if (pluginsProperty && ts.isArrayLiteralExpression(pluginsProperty.initializer)) {
             const pluginsArray = pluginsProperty.initializer;
             const lspPluginElement = pluginsArray.elements.find((element) => {
@@ -39742,6 +40222,13 @@ var computeTsConfigChanges = (current, target, lspVersion) => {
             }
           }
         } else {
+          if (!schemaProperty) {
+            descriptions.push("Add $schema to tsconfig");
+            insertNodeAtEndOfList(tracker, current.sourceFile, rootObj.properties, schemaPropertyAssignment);
+          } else if (!ts.isStringLiteral(schemaProperty.initializer) || schemaProperty.initializer.text !== TSCONFIG_SCHEMA_URL) {
+            descriptions.push("Update $schema in tsconfig");
+            tracker.replaceNode(current.sourceFile, schemaProperty.initializer, schemaPropertyAssignment.initializer);
+          }
           const buildPluginObject = (severities) => {
             const nameProperty = ts.factory.createPropertyAssignment(
               ts.factory.createStringLiteral("name"),