@effect/language-service 0.43.1 → 0.43.2

package/cli.js

@@ -28875,12 +28875,6 @@ var runMain2 = runMain;
 // node_modules/.pnpm/@effect+platform-node@0.96.0_@effect+cluster@0.48.2_@effect+platform@0.90.6_@effect+rpc@0.69._5eaod7sdztwbb2cfcwufk3knjm/node_modules/@effect/platform-node/dist/esm/NodeRuntime.js
 var runMain3 = runMain2;
 
-// src/cli/check.ts
-var ts2 = __toESM(require("typescript"));
-
-// src/cli/utils.ts
-var ts = __toESM(require("typescript"));
-
 // src/core/Nano.ts
 var NanoTag = class {
   constructor(key) {
@@ -29138,35 +29132,35 @@ function getPackageJsonInfoCache(program) {
   }
   return void 0;
 }
-function getDirectoryPath(ts4, path2) {
+function getDirectoryPath(ts, path2) {
   try {
-    if (hasProperty(ts4, "getDirectoryPath") && isFunction2(ts4.getDirectoryPath)) {
-      return ts4.getDirectoryPath(path2);
+    if (hasProperty(ts, "getDirectoryPath") && isFunction2(ts.getDirectoryPath)) {
+      return ts.getDirectoryPath(path2);
     }
     return path2;
   } catch (_) {
     return path2;
   }
 }
-function makeGetTemporaryModuleResolutionState(ts4) {
-  if (hasProperty(ts4, "getTemporaryModuleResolutionState") && isFunction2(ts4.getTemporaryModuleResolutionState)) {
-    const _internal = ts4.getTemporaryModuleResolutionState;
+function makeGetTemporaryModuleResolutionState(ts) {
+  if (hasProperty(ts, "getTemporaryModuleResolutionState") && isFunction2(ts.getTemporaryModuleResolutionState)) {
+    const _internal = ts.getTemporaryModuleResolutionState;
     return (cache, program, compilerOptions) => _internal(cache, program, compilerOptions);
   }
   return void 0;
 }
-function makeGetPackageScopeForPath(ts4) {
-  if (hasProperty(ts4, "getPackageScopeForPath") && isFunction2(ts4.getPackageScopeForPath)) {
-    const _internal = ts4.getPackageScopeForPath;
+function makeGetPackageScopeForPath(ts) {
+  if (hasProperty(ts, "getPackageScopeForPath") && isFunction2(ts.getPackageScopeForPath)) {
+    const _internal = ts.getPackageScopeForPath;
     return (path2, state) => _internal(path2, state);
   }
 }
 
 // src/core/TypeScriptUtils.ts
 var TypeScriptUtils = Tag4("TypeScriptUtils");
-function makeTypeScriptUtils(ts4) {
-  const getTemporaryModuleResolutionState = makeGetTemporaryModuleResolutionState(ts4);
-  const getPackageScopeForPath = makeGetPackageScopeForPath(ts4);
+function makeTypeScriptUtils(ts) {
+  const getTemporaryModuleResolutionState = makeGetTemporaryModuleResolutionState(ts);
+  const getPackageScopeForPath = makeGetPackageScopeForPath(ts);
   function parsePackageContentNameAndVersionFromScope(v) {
     if (!isObject(v)) return;
     if (!hasProperty(v, "packageJsonScope")) return;
@@ -29210,7 +29204,7 @@ function makeTypeScriptUtils(ts4) {
         program,
         program.getCompilerOptions()
       );
-      const directoryPath = getDirectoryPath(ts4, sourceFile.fileName);
+      const directoryPath = getDirectoryPath(ts, sourceFile.fileName);
       packageJsonScope = parsePackageContentNameAndVersionFromScope({
         ...sourceFile,
         packageJsonScope: getPackageScopeForPath(directoryPath, temporaryModuleResolutionState)
@@ -29223,7 +29217,7 @@ function makeTypeScriptUtils(ts4) {
     const packageJsonScope = resolveModuleWithPackageInfoFromSourceFile(program, sourceFile);
     const referencedPackages = [];
     for (const statement of sourceFile.statements) {
-      if (ts4.isImportDeclaration(statement) && ts4.isStringLiteral(statement.moduleSpecifier)) {
+      if (ts.isImportDeclaration(statement) && ts.isStringLiteral(statement.moduleSpecifier)) {
         const moduleSpecifier = statement.moduleSpecifier.text.toLowerCase();
         const packageName = moduleSpecifier.startsWith("@") ? moduleSpecifier.split("/", 2).join("/") : moduleSpecifier.split("/", 1).join("/");
         referencedPackages.push(packageName);
@@ -29242,7 +29236,7 @@ function makeTypeScriptUtils(ts4) {
     const sourceText = sourceFile.text;
     let result;
     function find3(node) {
-      const leading = ts4.getLeadingCommentRanges(sourceText, node.pos);
+      const leading = ts.getLeadingCommentRanges(sourceText, node.pos);
       if (leading) {
         for (const commentRange of leading) {
           if (commentRange.pos <= position && position < commentRange.end) {
@@ -29252,7 +29246,7 @@ function makeTypeScriptUtils(ts4) {
         }
       }
       if (node.pos <= position && position < node.end) {
-        ts4.forEachChild(node, find3);
+        ts.forEachChild(node, find3);
       }
     }
     find3(sourceFile);
@@ -29271,8 +29265,8 @@ function makeTypeScriptUtils(ts4) {
   }
   function findNodeAtPosition(sourceFile, position) {
     function find3(node) {
-      if (position >= ts4.getTokenPosOfNode(node, sourceFile) && position < node.end) {
-        return ts4.forEachChild(node, find3) || node;
+      if (position >= ts.getTokenPosOfNode(node, sourceFile) && position < node.end) {
+        return ts.forEachChild(node, find3) || node;
       }
       return void 0;
     }
@@ -29281,7 +29275,7 @@ function makeTypeScriptUtils(ts4) {
   function findNodeAtPositionIncludingTrivia(sourceFile, position) {
     function find3(node) {
       if (position >= node.pos && position < node.end) {
-        return ts4.forEachChild(node, find3) || node;
+        return ts.forEachChild(node, find3) || node;
       }
       return void 0;
     }
@@ -29294,11 +29288,11 @@ function makeTypeScriptUtils(ts4) {
   }
   function getCommentAtPosition(sourceFile, pos) {
     const token = findNodeAtPositionIncludingTrivia(sourceFile, pos);
-    if (token === void 0 || token.kind === ts4.SyntaxKind.JsxText || pos >= token.end - (ts4.tokenToString(token.kind) || "").length) {
+    if (token === void 0 || token.kind === ts.SyntaxKind.JsxText || pos >= token.end - (ts.tokenToString(token.kind) || "").length) {
       return;
     }
-    const startPos = token.pos === 0 ? (ts4.getShebang(sourceFile.text) || "").length : token.pos;
-    const result = ts4.forEachTrailingCommentRange(sourceFile.text, startPos, isCommentInRange, pos) || ts4.forEachLeadingCommentRange(sourceFile.text, startPos, isCommentInRange, pos);
+    const startPos = token.pos === 0 ? (ts.getShebang(sourceFile.text) || "").length : token.pos;
+    const result = ts.forEachTrailingCommentRange(sourceFile.text, startPos, isCommentInRange, pos) || ts.forEachLeadingCommentRange(sourceFile.text, startPos, isCommentInRange, pos);
     return result;
   }
   function isCommentInRange(pos, end5, kind, _nl, at) {
@@ -29312,45 +29306,45 @@ function makeTypeScriptUtils(ts4) {
   }
   function transformAsyncAwaitToEffectGeneratorBody(body, onAwait) {
     function visitor(_) {
-      if (ts4.isAwaitExpression(_)) {
-        const expression = ts4.visitEachChild(_.expression, visitor, ts4.nullTransformationContext);
-        return ts4.factory.createYieldExpression(
-          ts4.factory.createToken(ts4.SyntaxKind.AsteriskToken),
+      if (ts.isAwaitExpression(_)) {
+        const expression = ts.visitEachChild(_.expression, visitor, ts.nullTransformationContext);
+        return ts.factory.createYieldExpression(
+          ts.factory.createToken(ts.SyntaxKind.AsteriskToken),
           onAwait(expression)
         );
       }
-      return ts4.visitEachChild(_, visitor, ts4.nullTransformationContext);
+      return ts.visitEachChild(_, visitor, ts.nullTransformationContext);
     }
     return visitor(body);
   }
   function transformAsyncAwaitToEffectFn(node, effectModuleName, onAwait) {
     const generatorBody = transformAsyncAwaitToEffectGeneratorBody(node.body, onAwait);
-    const fnName = node.name && ts4.isIdentifier(node.name) ? node.name : ts4.isVariableDeclaration(node.parent) && ts4.isIdentifier(node.parent.name) && node.parent.initializer === node ? node.parent.name : void 0;
-    let fnCall = ts4.factory.createPropertyAccessExpression(
-      ts4.factory.createIdentifier(effectModuleName),
+    const fnName = node.name && ts.isIdentifier(node.name) ? node.name : ts.isVariableDeclaration(node.parent) && ts.isIdentifier(node.parent.name) && node.parent.initializer === node ? node.parent.name : void 0;
+    let fnCall = ts.factory.createPropertyAccessExpression(
+      ts.factory.createIdentifier(effectModuleName),
       "fn"
     );
     if (fnName) {
-      fnCall = ts4.factory.createCallExpression(
+      fnCall = ts.factory.createCallExpression(
         fnCall,
         void 0,
-        [ts4.factory.createStringLiteral(ts4.idText(fnName))]
+        [ts.factory.createStringLiteral(ts.idText(fnName))]
       );
     }
     return tryPreserveDeclarationSemantics(
       node,
-      ts4.factory.createCallExpression(
+      ts.factory.createCallExpression(
         fnCall,
         void 0,
         [
-          ts4.factory.createFunctionExpression(
+          ts.factory.createFunctionExpression(
             void 0,
-            ts4.factory.createToken(ts4.SyntaxKind.AsteriskToken),
+            ts.factory.createToken(ts.SyntaxKind.AsteriskToken),
             void 0,
             node.typeParameters,
             node.parameters,
             void 0,
-            ts4.isBlock(generatorBody) ? generatorBody : ts4.factory.createBlock([ts4.factory.createReturnStatement(generatorBody)])
+            ts.isBlock(generatorBody) ? generatorBody : ts.factory.createBlock([ts.factory.createReturnStatement(generatorBody)])
           )
         ]
       ),
@@ -29360,11 +29354,11 @@ function makeTypeScriptUtils(ts4) {
   function transformAsyncAwaitToEffectGen(node, effectModuleName, onAwait) {
     const generatorBody = transformAsyncAwaitToEffectGeneratorBody(node.body, onAwait);
     const effectGenCallExp = createEffectGenCallExpression(effectModuleName, generatorBody);
-    let currentFlags = ts4.getCombinedModifierFlags(node);
-    currentFlags &= ~ts4.ModifierFlags.Async;
-    const newModifiers = ts4.factory.createModifiersFromModifierFlags(currentFlags);
-    if (ts4.isArrowFunction(node)) {
-      return ts4.factory.createArrowFunction(
+    let currentFlags = ts.getCombinedModifierFlags(node);
+    currentFlags &= ~ts.ModifierFlags.Async;
+    const newModifiers = ts.factory.createModifiersFromModifierFlags(currentFlags);
+    if (ts.isArrowFunction(node)) {
+      return ts.factory.createArrowFunction(
         newModifiers,
         node.typeParameters,
         node.parameters,
@@ -29373,11 +29367,11 @@ function makeTypeScriptUtils(ts4) {
         effectGenCallExp
       );
     }
-    const newBody = ts4.factory.createBlock([
-      ts4.factory.createReturnStatement(effectGenCallExp)
+    const newBody = ts.factory.createBlock([
+      ts.factory.createReturnStatement(effectGenCallExp)
     ]);
-    if (ts4.isFunctionDeclaration(node)) {
-      return ts4.factory.createFunctionDeclaration(
+    if (ts.isFunctionDeclaration(node)) {
+      return ts.factory.createFunctionDeclaration(
         newModifiers,
         node.asteriskToken,
         node.name,
@@ -29387,7 +29381,7 @@ function makeTypeScriptUtils(ts4) {
         newBody
       );
     }
-    return ts4.factory.createFunctionExpression(
+    return ts.factory.createFunctionExpression(
       newModifiers,
       node.asteriskToken,
       node.name,
@@ -29399,22 +29393,22 @@ function makeTypeScriptUtils(ts4) {
   }
   function findImportedModuleIdentifier(sourceFile, test) {
     for (const statement of sourceFile.statements) {
-      if (!ts4.isImportDeclaration(statement)) continue;
+      if (!ts.isImportDeclaration(statement)) continue;
       const importClause = statement.importClause;
       if (!importClause) continue;
       const namedBindings = importClause.namedBindings;
       if (!namedBindings) continue;
-      if (ts4.isNamespaceImport(namedBindings)) {
+      if (ts.isNamespaceImport(namedBindings)) {
         if (test(namedBindings.name, statement.moduleSpecifier, none2())) {
-          return ts4.idText(namedBindings.name);
+          return ts.idText(namedBindings.name);
         }
-      } else if (ts4.isNamedImports(namedBindings)) {
+      } else if (ts.isNamedImports(namedBindings)) {
         for (const importSpecifier of namedBindings.elements) {
           const importProperty = fromNullable(importSpecifier.propertyName).pipe(
             orElse(() => some2(importSpecifier.name))
           );
           if (test(importSpecifier.name, statement.moduleSpecifier, importProperty)) {
-            return ts4.idText(importSpecifier.name);
+            return ts.idText(importSpecifier.name);
           }
         }
       }
@@ -29424,10 +29418,10 @@ function makeTypeScriptUtils(ts4) {
     return findImportedModuleIdentifier(
       sourceFile,
       (_, fromModule, importProperty) => {
-        if (isNone2(importProperty) && ts4.isStringLiteral(fromModule) && fromModule.text === packageName + "/" + moduleName) {
+        if (isNone2(importProperty) && ts.isStringLiteral(fromModule) && fromModule.text === packageName + "/" + moduleName) {
           return true;
         }
-        if (isSome2(importProperty) && ts4.isIdentifier(importProperty.value) && ts4.idText(importProperty.value) === moduleName && ts4.isStringLiteral(fromModule) && fromModule.text === packageName) {
+        if (isSome2(importProperty) && ts.isIdentifier(importProperty.value) && ts.idText(importProperty.value) === moduleName && ts.isStringLiteral(fromModule) && fromModule.text === packageName) {
           return true;
         }
         return false;
@@ -29436,19 +29430,19 @@ function makeTypeScriptUtils(ts4) {
   }
   function simplifyTypeNode(typeNode) {
     function collectCallable(typeNode2) {
-      if (ts4.isParenthesizedTypeNode(typeNode2)) return collectCallable(typeNode2.type);
-      if (ts4.isFunctionTypeNode(typeNode2)) {
+      if (ts.isParenthesizedTypeNode(typeNode2)) return collectCallable(typeNode2.type);
+      if (ts.isFunctionTypeNode(typeNode2)) {
         return some2([
-          ts4.factory.createCallSignature(typeNode2.typeParameters, typeNode2.parameters, typeNode2.type)
+          ts.factory.createCallSignature(typeNode2.typeParameters, typeNode2.parameters, typeNode2.type)
         ]);
       }
-      if (ts4.isTypeLiteralNode(typeNode2)) {
-        const allCallSignatures = typeNode2.members.every(ts4.isCallSignatureDeclaration);
+      if (ts.isTypeLiteralNode(typeNode2)) {
+        const allCallSignatures = typeNode2.members.every(ts.isCallSignatureDeclaration);
         if (allCallSignatures) {
           return some2(typeNode2.members);
         }
       }
-      if (ts4.isIntersectionTypeNode(typeNode2)) {
+      if (ts.isIntersectionTypeNode(typeNode2)) {
         const members = typeNode2.types.map((node) => collectCallable(node));
         if (members.every(isSome2)) {
           return some2(members.map((_) => isSome2(_) ? _.value : []).flat());
@@ -29458,34 +29452,34 @@ function makeTypeScriptUtils(ts4) {
     }
     const callSignatures = collectCallable(typeNode);
     if (isSome2(callSignatures) && callSignatures.value.length > 1) {
-      return ts4.factory.createTypeLiteralNode(callSignatures.value);
+      return ts.factory.createTypeLiteralNode(callSignatures.value);
     }
     return typeNode;
   }
   function tryPreserveDeclarationSemantics(nodeToReplace, node, dropAsync) {
-    if (!ts4.isExpression(node)) return node;
-    if (ts4.isFunctionDeclaration(nodeToReplace)) {
+    if (!ts.isExpression(node)) return node;
+    if (ts.isFunctionDeclaration(nodeToReplace)) {
       if (!nodeToReplace.name) return node;
-      let currentFlags = ts4.getCombinedModifierFlags(nodeToReplace);
-      currentFlags &= ~ts4.ModifierFlags.Async;
-      const newModifiers = dropAsync ? ts4.factory.createModifiersFromModifierFlags(currentFlags) : nodeToReplace.modifiers;
-      return ts4.factory.createVariableStatement(
+      let currentFlags = ts.getCombinedModifierFlags(nodeToReplace);
+      currentFlags &= ~ts.ModifierFlags.Async;
+      const newModifiers = dropAsync ? ts.factory.createModifiersFromModifierFlags(currentFlags) : nodeToReplace.modifiers;
+      return ts.factory.createVariableStatement(
         newModifiers,
-        ts4.factory.createVariableDeclarationList(
-          [ts4.factory.createVariableDeclaration(
+        ts.factory.createVariableDeclarationList(
+          [ts.factory.createVariableDeclaration(
             nodeToReplace.name,
             void 0,
             void 0,
             node
           )],
-          ts4.NodeFlags.Const
+          ts.NodeFlags.Const
         )
       );
-    } else if (ts4.isMethodDeclaration(nodeToReplace)) {
-      let currentFlags = ts4.getCombinedModifierFlags(nodeToReplace);
-      currentFlags &= ~ts4.ModifierFlags.Async;
-      const newModifiers = dropAsync ? ts4.factory.createModifiersFromModifierFlags(currentFlags) : nodeToReplace.modifiers;
-      return ts4.factory.createPropertyDeclaration(
+    } else if (ts.isMethodDeclaration(nodeToReplace)) {
+      let currentFlags = ts.getCombinedModifierFlags(nodeToReplace);
+      currentFlags &= ~ts.ModifierFlags.Async;
+      const newModifiers = dropAsync ? ts.factory.createModifiersFromModifierFlags(currentFlags) : nodeToReplace.modifiers;
+      return ts.factory.createPropertyDeclaration(
         newModifiers,
         nodeToReplace.name,
         void 0,
@@ -29496,30 +29490,30 @@ function makeTypeScriptUtils(ts4) {
     return node;
   }
   function parseAccessedExpressionForCompletion(sourceFile, position) {
-    const precedingToken = ts4.findPrecedingToken(position, sourceFile, void 0, true);
+    const precedingToken = ts.findPrecedingToken(position, sourceFile, void 0, true);
     if (!precedingToken) return;
     let accessedObject = precedingToken;
-    let replacementSpan = ts4.createTextSpan(position, 0);
+    let replacementSpan = ts.createTextSpan(position, 0);
     let outerNode = precedingToken;
-    if (ts4.isIdentifier(precedingToken) && precedingToken.parent && ts4.isPropertyAccessExpression(precedingToken.parent)) {
-      const spanStart = ts4.getTokenPosOfNode(precedingToken.parent, sourceFile);
-      replacementSpan = ts4.createTextSpan(
+    if (ts.isIdentifier(precedingToken) && precedingToken.parent && ts.isPropertyAccessExpression(precedingToken.parent)) {
+      const spanStart = ts.getTokenPosOfNode(precedingToken.parent, sourceFile);
+      replacementSpan = ts.createTextSpan(
         spanStart,
         precedingToken.end - spanStart
       );
       accessedObject = precedingToken.parent.expression;
       outerNode = precedingToken.parent;
-    } else if (ts4.isToken(precedingToken) && precedingToken.kind === ts4.SyntaxKind.DotToken && ts4.isPropertyAccessExpression(precedingToken.parent)) {
-      const precedingTokenSpanStart = ts4.getTokenPosOfNode(precedingToken.parent, sourceFile);
-      replacementSpan = ts4.createTextSpan(
+    } else if (ts.isToken(precedingToken) && precedingToken.kind === ts.SyntaxKind.DotToken && ts.isPropertyAccessExpression(precedingToken.parent)) {
+      const precedingTokenSpanStart = ts.getTokenPosOfNode(precedingToken.parent, sourceFile);
+      replacementSpan = ts.createTextSpan(
         precedingTokenSpanStart,
         precedingToken.end - precedingTokenSpanStart
       );
       accessedObject = precedingToken.parent.expression;
       outerNode = precedingToken.parent;
-    } else if (ts4.isIdentifier(precedingToken) && precedingToken.parent) {
-      const precedingTokenSpanStart = ts4.getTokenPosOfNode(precedingToken, sourceFile);
-      replacementSpan = ts4.createTextSpan(
+    } else if (ts.isIdentifier(precedingToken) && precedingToken.parent) {
+      const precedingTokenSpanStart = ts.getTokenPosOfNode(precedingToken, sourceFile);
+      replacementSpan = ts.createTextSpan(
         precedingTokenSpanStart,
         precedingToken.end - precedingTokenSpanStart
       );
@@ -29534,13 +29528,13 @@ function makeTypeScriptUtils(ts4) {
     const maybeInfos = parseAccessedExpressionForCompletion(sourceFile, position);
     if (!maybeInfos) return;
     const { accessedObject, outerNode, replacementSpan } = maybeInfos;
-    if (!ts4.isIdentifier(accessedObject)) return;
+    if (!ts.isIdentifier(accessedObject)) return;
     let classDeclaration = outerNode.parent;
-    while (ts4.isExpressionWithTypeArguments(classDeclaration) || ts4.isHeritageClause(classDeclaration)) {
+    while (ts.isExpressionWithTypeArguments(classDeclaration) || ts.isHeritageClause(classDeclaration)) {
       if (!classDeclaration.parent) break;
       classDeclaration = classDeclaration.parent;
     }
-    if (!ts4.isClassDeclaration(classDeclaration)) return;
+    if (!ts.isClassDeclaration(classDeclaration)) return;
     if (!classDeclaration.name) return;
     return {
       accessedObject,
@@ -29550,9 +29544,9 @@ function makeTypeScriptUtils(ts4) {
     };
   }
   function createEffectGenCallExpression(effectModuleIdentifierName, node) {
-    const generator = ts4.factory.createFunctionExpression(
+    const generator = ts.factory.createFunctionExpression(
       void 0,
-      ts4.factory.createToken(ts4.SyntaxKind.AsteriskToken),
+      ts.factory.createToken(ts.SyntaxKind.AsteriskToken),
       void 0,
       [],
       [],
@@ -29560,9 +29554,9 @@ function makeTypeScriptUtils(ts4) {
       node
       // NOTE(mattia): intended, to use same routine for both ConciseBody and Body
     );
-    return ts4.factory.createCallExpression(
-      ts4.factory.createPropertyAccessExpression(
-        ts4.factory.createIdentifier(effectModuleIdentifierName),
+    return ts.factory.createCallExpression(
+      ts.factory.createPropertyAccessExpression(
+        ts.factory.createIdentifier(effectModuleIdentifierName),
         "gen"
       ),
       void 0,
@@ -29572,41 +29566,41 @@ function makeTypeScriptUtils(ts4) {
   function createEffectGenCallExpressionWithBlock(effectModuleIdentifierName, statement) {
     return createEffectGenCallExpression(
       effectModuleIdentifierName,
-      ts4.factory.createBlock(isArray(statement) ? statement : [statement], false)
+      ts.factory.createBlock(isArray(statement) ? statement : [statement], false)
     );
   }
   function createReturnYieldStarStatement(expr) {
-    return ts4.factory.createReturnStatement(
-      ts4.factory.createYieldExpression(
-        ts4.factory.createToken(ts4.SyntaxKind.AsteriskToken),
+    return ts.factory.createReturnStatement(
+      ts.factory.createYieldExpression(
+        ts.factory.createToken(ts.SyntaxKind.AsteriskToken),
         expr
       )
     );
   }
   function createDataTaggedErrorDeclaration(dataModuleIdentifier, name, fields) {
-    const invokeTaggedError = ts4.factory.createCallExpression(
-      ts4.factory.createPropertyAccessExpression(
-        ts4.factory.createIdentifier(dataModuleIdentifier),
+    const invokeTaggedError = ts.factory.createCallExpression(
+      ts.factory.createPropertyAccessExpression(
+        ts.factory.createIdentifier(dataModuleIdentifier),
         "TaggedError"
       ),
       void 0,
       [
-        ts4.factory.createStringLiteral(name)
+        ts.factory.createStringLiteral(name)
       ]
     );
-    const withTypeFields = ts4.factory.createExpressionWithTypeArguments(
+    const withTypeFields = ts.factory.createExpressionWithTypeArguments(
       invokeTaggedError,
       [
-        ts4.factory.createTypeLiteralNode(fields)
+        ts.factory.createTypeLiteralNode(fields)
       ]
     );
-    return ts4.factory.createClassDeclaration(
-      [ts4.factory.createModifier(ts4.SyntaxKind.ExportKeyword)],
+    return ts.factory.createClassDeclaration(
+      [ts.factory.createModifier(ts.SyntaxKind.ExportKeyword)],
       name,
       void 0,
       [
-        ts4.factory.createHeritageClause(
-          ts4.SyntaxKind.ExtendsKeyword,
+        ts.factory.createHeritageClause(
+          ts.SyntaxKind.ExtendsKeyword,
           [
             withTypeFields
           ]
@@ -29617,7 +29611,7 @@ function makeTypeScriptUtils(ts4) {
   }
   function getSourceFileOfNode(current) {
     let node = current;
-    while (node && node.kind !== ts4.SyntaxKind.SourceFile) {
+    while (node && node.kind !== ts.SyntaxKind.SourceFile) {
       node = node.parent;
     }
     return node;
@@ -29647,7 +29641,6 @@ function makeTypeScriptUtils(ts4) {
 }
 
 // src/cli/utils.ts
-var tsUtils = makeTypeScriptUtils(ts);
 var PackageJsonSchema = Struct({
   name: String$,
   version: String$,
@@ -29671,6 +29664,16 @@ var CorruptedPatchedSourceFileError = class extends TaggedError("CorruptedPatche
     return `Patched source file ${this.filePath} has corrupted patches`;
   }
 };
+var UnableToFindInstalledTypeScriptPackage = class extends TaggedError("UnableToFindInstalledTypeScriptPackage") {
+  get message() {
+    return `Unable to find an installed typescript package`;
+  }
+};
+var getTypeScript = try_3({
+  // eslint-disable-next-line @typescript-eslint/no-require-imports
+  try: () => require("typescript"),
+  catch: (cause2) => new UnableToFindInstalledTypeScriptPackage({ cause: cause2 })
+});
 var getPackageJsonData = fn("getPackageJsonData")(function* (packageDir) {
   const path2 = yield* Path2;
   const fs = yield* FileSystem;
@@ -29760,6 +29763,8 @@ var makeEffectLspPatchChange = fn("makeEffectLspPatchChange")(
 );
 var extractAppliedEffectLspPatches = fn("extractAppliedEffectLspPatches")(
   function* (sourceFile) {
+    const ts = yield* getTypeScript;
+    const tsUtils = makeTypeScriptUtils(ts);
     const regex = /@effect-lsp-patch(?:\s+)([a-zA-Z0-9+=/]+)/gm;
     let match18;
     const patches = [];
@@ -29806,6 +29811,7 @@ var applyTextChanges = fn("applyTextChanges")(
 );
 var getUnpatchedSourceFile = fn("getUnpatchedSourceFile")(function* (filePath) {
   const fs = yield* FileSystem;
+  const ts = yield* getTypeScript;
   const sourceText = yield* fs.readFileString(filePath);
   const sourceFile = ts.createSourceFile(
     filePath,
@@ -29826,6 +29832,7 @@ var getUnpatchedSourceFile = fn("getUnpatchedSourceFile")(function* (filePath) {
 });
 var omitBundlerSourceFileComment = fn("omitBundlerSourceFileComment")(
   function* (originalSourceText) {
+    const ts = yield* getTypeScript;
     const deleteChanges = [];
     const sourceFile = ts.createSourceFile(
       "file.ts",
@@ -29860,6 +29867,7 @@ var check2 = make58(
   { dirPath },
   fn("check")(function* ({ dirPath: dirPath4 }) {
     const fs = yield* FileSystem;
+    const ts = yield* getTypeScript;
     const { version: effectLspVersion } = yield* getPackageJsonData(__dirname);
     yield* logDebug2(`Found @effect/language-service version ${effectLspVersion}!`);
     yield* logDebug2(`Searching for typescript in ${dirPath4}...`);
@@ -29870,7 +29878,7 @@ var check2 = make58(
       const filePath = yield* getModuleFilePath(dirPath4, moduleName);
       yield* logDebug2(`Reading ${moduleName} from ${filePath}...`);
       const sourceText = yield* fs.readFileString(filePath);
-      const sourceFile = ts2.createSourceFile(filePath, sourceText, ts2.ScriptTarget.ES2022, true);
+      const sourceFile = ts.createSourceFile(filePath, sourceText, ts.ScriptTarget.ES2022, true);
       yield* logDebug2(`Collecting patches for ${moduleName}...`);
       const { patches } = yield* extractAppliedEffectLspPatches(sourceFile);
       const patchesVersion = pipe(patches, map3((patch10) => patch10.version), dedupe);
@@ -29884,7 +29892,6 @@ var check2 = make58(
 );
 
 // src/cli/patch.ts
-var ts3 = __toESM(require("typescript"));
 var UnableToFindPositionToPatchError = class extends TaggedError("UnableToFindPositionToPatchError") {
   get message() {
     return `Unable to find position to patch ${this.positionToFind}`;
@@ -29904,6 +29911,7 @@ var moduleNames = choice3("module", [
 );
 var getPatchesForModule = fn("getPatchesForModule")(
   function* (moduleName, dirPath4, version, sourceFile) {
+    const ts = yield* getTypeScript;
     const patches = [];
     let insertClearSourceFileEffectMetadataPosition = none2();
     let insertCheckSourceFilePosition = none2();
@@ -29913,7 +29921,7 @@ var getPatchesForModule = fn("getPatchesForModule")(
     function findNodeAtPositionIncludingTrivia(sourceFile2, position) {
       function find3(node) {
         if (position >= node.pos && position < node.end) {
-          return ts3.forEachChild(node, find3) || node;
+          return ts.forEachChild(node, find3) || node;
         }
         return void 0;
       }
@@ -29926,7 +29934,7 @@ var getPatchesForModule = fn("getPatchesForModule")(
       while ((match18 = regex.exec(sourceFile.text)) !== null) {
         const node = findNodeAtPositionIncludingTrivia(sourceFile, match18.index);
         if (node) {
-          const functionDeclaration = ts3.findAncestor(node, ts3.isFunctionDeclaration);
+          const functionDeclaration = ts.findAncestor(node, ts.isFunctionDeclaration);
           nodesToCheck.push(functionDeclaration || node);
           pushed = true;
         }
@@ -29941,14 +29949,14 @@ var getPatchesForModule = fn("getPatchesForModule")(
     while (nodesToCheck.length > 0) {
       const node = nodesToCheck.shift();
       if (!node) continue;
-      if (ts3.isExpressionStatement(node)) {
+      if (ts.isExpressionStatement(node)) {
         const expression = node.expression;
-        if (ts3.isCallExpression(expression)) {
+        if (ts.isCallExpression(expression)) {
           const identifier2 = expression.expression;
-          if (ts3.isIdentifier(identifier2) && ts3.idText(identifier2) === "checkGrammarSourceFile" && ts3.isBlock(node.parent) && node.parent.statements.length > 0) {
+          if (ts.isIdentifier(identifier2) && ts.idText(identifier2) === "checkGrammarSourceFile" && ts.isBlock(node.parent) && node.parent.statements.length > 0) {
             const block = node.parent;
-            const parentFunctionDeclaration = ts3.findAncestor(node, ts3.isFunctionDeclaration);
-            if (parentFunctionDeclaration && parentFunctionDeclaration.name && ts3.isIdentifier(parentFunctionDeclaration.name) && ts3.idText(parentFunctionDeclaration.name) === "checkSourceFileWorker") {
+            const parentFunctionDeclaration = ts.findAncestor(node, ts.isFunctionDeclaration);
+            if (parentFunctionDeclaration && parentFunctionDeclaration.name && ts.isIdentifier(parentFunctionDeclaration.name) && ts.idText(parentFunctionDeclaration.name) === "checkSourceFileWorker") {
               insertClearSourceFileEffectMetadataPosition = some2({ position: node.pos });
               insertCheckSourceFilePosition = some2({
                 position: block.statements[block.statements.length - 1].end
@@ -29956,13 +29964,13 @@ var getPatchesForModule = fn("getPatchesForModule")(
             }
           }
         }
-      } else if (ts3.isFunctionDeclaration(node)) {
-        if (node.name && ts3.isIdentifier(node.name) && ts3.idText(node.name) === "markPrecedingCommentDirectiveLine" && node.body && node.body.statements.length > 0) {
+      } else if (ts.isFunctionDeclaration(node)) {
+        if (node.name && ts.isIdentifier(node.name) && ts.idText(node.name) === "markPrecedingCommentDirectiveLine" && node.body && node.body.statements.length > 0) {
           insertSkipPrecedingCommentDirectivePosition = some2({ position: node.body.statements[0].pos });
         }
-        if (node.name && ts3.isIdentifier(node.name) && ts3.idText(node.name) === "reportRelationError" && node.body && node.body.statements.length > 0 && node.parameters.length >= 3) {
-          const sourceIdentifier2 = node.parameters[1] && ts3.isParameter(node.parameters[1]) && ts3.isIdentifier(node.parameters[1].name) ? ts3.idText(node.parameters[1].name) : void 0;
-          const targetIdentifier2 = node.parameters[2] && ts3.isParameter(node.parameters[2]) && ts3.isIdentifier(node.parameters[2].name) ? ts3.idText(node.parameters[2].name) : void 0;
+        if (node.name && ts.isIdentifier(node.name) && ts.idText(node.name) === "reportRelationError" && node.body && node.body.statements.length > 0 && node.parameters.length >= 3) {
+          const sourceIdentifier2 = node.parameters[1] && ts.isParameter(node.parameters[1]) && ts.isIdentifier(node.parameters[1].name) ? ts.idText(node.parameters[1].name) : void 0;
+          const targetIdentifier2 = node.parameters[2] && ts.isParameter(node.parameters[2]) && ts.isIdentifier(node.parameters[2].name) ? ts.idText(node.parameters[2].name) : void 0;
           if (sourceIdentifier2 && targetIdentifier2) {
             insertAppendMetadataRelationErrorPosition = some2({
               position: node.body.statements[0].pos,
@@ -29972,7 +29980,7 @@ var getPatchesForModule = fn("getPatchesForModule")(
           }
         }
       }
-      ts3.forEachChild(node, (child) => {
+      ts.forEachChild(node, (child) => {
         nodesToCheck.push(child);
         return void 0;
       });