firefly-compiler 0.5.63 → 0.5.65

package/fireflysite/Router.ff

@@ -1,8 +1,8 @@
 import WebServer from ff:webserver
 import WebRoute from ff:webserver
-import RouteFront
-import RouteReference
-import RouteNonMarkdown
+import routes.RouteFront
+import routes.RouteReference
+import routes.RouteNonMarkdown
 
 capability RouteContext(system: NodeSystem)
 

package/fireflysite/{ExamplesOverview.ff → demos/ExamplesOverview.ff}

@@ -1,7 +1,7 @@
 import Guide
-import CountingButtonDemo
-import MatchingPasswordsDemo
-import PostgresqlDemo
+import demos.CountingButtonDemo
+import demos.MatchingPasswordsDemo
+import demos.PostgresqlDemo
 
 demos(): List[Demo] {
     [

package/fireflysite/{RouteFront.ff → routes/RouteFront.ff}

@@ -2,13 +2,12 @@ import Lux from ff:lux
 import WebServer from ff:webserver
 import Router
 import Guide
-import ExamplesOverview
 import FrontPage
 import Html
 import Website
 import Menu
 
-routeModule = SourceLocation.here().module()
+routeModule = SourceLocation.here().directoryAndModule()
 
 data PageData(sections: List[Section])
 
@@ -25,6 +24,6 @@ browserMain(system: BrowserSystem) {
 render(lux: Lux, data: PageData) {
     let next = None // TODO MenuItem(["getting-started"], Menu.menu.grabFirst().name, None)
     Website.renderContentWithNext(lux, [], next) {lux =>
-        Guide.renderSections(lux, data.sections, ExamplesOverview.demos())
+        Guide.renderSections(lux, data.sections, [])
     }
 }

package/fireflysite/{RouteNonMarkdown.ff → routes/RouteNonMarkdown.ff}

@@ -2,18 +2,18 @@ import Lux from ff:lux
 import WebServer from ff:webserver
 import Router
 import Guide
-import ExamplesOverview
+import demos.ExamplesOverview
 import GettingStarted
-import CountingButtonDemo
-import MatchingPasswordsDemo
-import PostgresqlDemo
+import demos.CountingButtonDemo
+import demos.MatchingPasswordsDemo
+import demos.PostgresqlDemo
 import Html
 import Website
 import Menu
 import PackagesOverview
 import CommunityOverview
 
-routeModule = SourceLocation.here().module()
+routeModule = SourceLocation.here().directoryAndModule()
 
 data PageData(menuEntry: MenuItem, sections: List[Section])
 

package/fireflysite/{RouteReference.ff → routes/RouteReference.ff}

@@ -2,14 +2,13 @@ import Lux from ff:lux
 import WebServer from ff:webserver
 import Router
 import Guide
-import ExamplesOverview
 import FrontPage
 import DocumentParser
 import Html
 import Website
 import Menu
 
-routeModule = SourceLocation.here().module()
+routeModule = SourceLocation.here().directoryAndModule()
 
 data PageData(menuEntry: MenuItem, sections: List[Section])
 
@@ -35,6 +34,6 @@ browserMain(system: BrowserSystem) {
 
 render(lux: Lux, data: PageData) {
     Website.renderContentWithNext(lux, data.menuEntry.path, data.menuEntry.next) {lux =>
-        Guide.renderSections(lux, data.sections, ExamplesOverview.demos())
+        Guide.renderSections(lux, data.sections, [])
     }
 }

package/lsp/CompletionHandler.ff

@@ -250,10 +250,10 @@ completion(
                 } else {
                     let module = name.dropLast(shorter.size() + 1)
                     let alias = environment.imports.find {_, i =>
-                        module == i.package.groupName() + "/" + i.directory.map {_ + "/"}.join() + i.file
+                        module == i.moduleKey.qualifiedName()
                     }
                     alias.map {| Pair(alias, i) =>
-                        Pair(alias + short.dropFirst(i.file.size()), scheme)
+                        Pair(alias + "." + shorter, scheme)
                     }
                 }
             | _ =>

package/lsp/Handler.ff

@@ -273,7 +273,8 @@ extend self: Handler {
             let lspHook = LspHook.new(at = None, definedAt = None, insertIdentifier = False, trackSymbols = True)
             let code = self.virtualFiles.get(path.absolute()).else {path.readText()}
             let tokens = Tokenizer.tokenize(path.absolute(), code, None, True)
-            let parser = Parser.new(PackagePair("script", "script"), path.absolute(), tokens, False, lspHook)
+            let dummyModuleKey = ModuleKey(PackagePair("script", "script"), [], path.base())
+            let parser = Parser.new(dummyModuleKey, tokens, False, lspHook)
             parser.parseModuleWithPackageInfo()
             SymbolHandler.readAllSymbols(lspHook.results())
         } tryCatch {| CompileError(at, message), error =>
@@ -368,6 +369,7 @@ extend self: Handler {
         let lspHook = LspHook.new(at = Some(targetAt), definedAt = None, insertIdentifier = False, trackSymbols = False)
         let path = system.path(targetAt.file)
         let errors = self.check(system, self.fireflyPath, path, None, Set.new(), self.virtualFiles, version, lspHook, True)
+        Log.trace("errors: " + Show.show(errors))
         errors.each {| CompileError(at, message) => 
             Log.trace("handleHover check error: " + message)
         }
@@ -403,7 +405,8 @@ extend self: Handler {
         try {
             let code = self.virtualFiles.get(cursorAt.file).else {system.path(cursorAt.file).readText()}
             let tokens = Tokenizer.tokenize(cursorAt.file, code, None, True)
-            let parser = Parser.new(PackagePair("script", "script"), cursorAt.file, tokens, False, lspHook)
+            let dummyModuleKey = ModuleKey(PackagePair("script", "script"), [], "<LSP>")
+            let parser = Parser.new(dummyModuleKey, tokens, False, lspHook)
             parser.parseModuleWithPackageInfo()
         } tryCatch {| CompileError(at, message), error =>
             Log.trace("handleSignatureHelp check error: " + message)
@@ -521,14 +524,14 @@ extend self: Handler {
             qualifiedName.split('.').grabLast().split('_').grabLast()
         }
 
-        function extractModuleName(qualifiedName: String): String {
-            qualifiedName.split('/').grabLast().takeWhile {c => c != '.' || c == '_'}
-        }
-
-        function extractPackagePair(qualifiedName: String): PackagePair {
+        function extractModuleKey(qualifiedName: String): ModuleKey {
             let group = qualifiedName.split(':').grabFirst()
             let name = qualifiedName.split(':').grabLast().takeWhile {_ != '/'}
-            PackagePair(group, name)
+            let packagePair = PackagePair(group, name)
+            let moduleParts = qualifiedName.split('/').dropFirst()
+            let moduleFolders = moduleParts.dropLast()
+            let moduleName = moduleParts.grabLast().takeWhile {c => c != '.' || c == '_'}
+            ModuleKey(packagePair, moduleFolders, moduleName)
         }
 
         definedAtList.first().{
@@ -541,18 +544,18 @@ extend self: Handler {
                 mustContain.each {Log.trace("mustContain: " + _)}
                 
                 let skipFiles = if(definition.name.contains(":")) {
-                    let list = self.moduleCache.filesNotImporting(extractPackagePair(definition.name), extractModuleName(definition.name))
+                    let list = self.moduleCache.filesNotImporting(extractModuleKey(definition.name))
                     list.toSet()
                 } else {
                     self.moduleCache.parsedModules.get(definition.at.file).map {| Pair(module, _) =>
-                        let list = self.moduleCache.filesNotImporting(module.packagePair, module.file.dropLast(3))
+                        let list = self.moduleCache.filesNotImporting(module.moduleKey)
                         list.toSet()
                     }.else {
                         Log.trace("No skip list due to unqualified definition.name: " + definition.name)
                         Set.new()
                     }
                 }
-                let errors = self.check(system, self.fireflyPath, path, mustContain, skipFiles, self.virtualFiles, version, lspHook, True, False)
+                let errors = self.check(system, self.fireflyPath, path, mustContain, skipFiles, self.virtualFiles, version, lspHook, True)
                 errors.each {| CompileError(at, message) => 
                     Log.trace("findReferences second check error: " + message + " in " + at.file + ":" + at.line + ":" + at.column)
                 }
@@ -698,7 +701,6 @@ extend self: Handler {
         newModuleCacheVersion: Int
         lspHook: LspHook
         infer: Bool
-        checkDependencies: Bool = True
     ): List[CompileError] {
         Builder.check(
             system
@@ -712,7 +714,6 @@ extend self: Handler {
             newModuleCacheVersion
             lspHook
             infer
-            checkDependencies
         )
     }
 

package/lsp/LanguageServer.ff

@@ -63,18 +63,19 @@ main(system: NodeSystem) {
                 let message = parseRequestMessage(request.object)
                 logDirectory.each {logMessage(_, "request", request.object, message.method)}
                 spawn(message.id) {_ =>
-                    if(message.method == "$/cancelRequest") {
-                        abort(Some(parseMessageId(message.parameters.grab("id"))))
-                    }
                     try {
+                        if(message.method == "$/cancelRequest") {
+                            abort(Some(parseMessageId(message.parameters.grab("id"))))
+                        }
                         handleRequestMessage(system, handler, message, version).each {body =>
                             responseChannel.write(Pair(body, message.method))
                         }
                     } catchAny {error =>
                         let problem = if(error.name() == "AbortError") {
+                            Log.trace("LS ABORT")
                             Error(-32800, "Request cancelled")
                         } else {
-                            Log.trace("ERROR: " + error.message())
+                            Log.trace("LS ERROR " + error.name() + ": " + error.message())
                             Log.trace(error.stack())
                             Error(-32603, "Internal error")
                         }

package/output/js/ff/compiler/Builder.mjs

@@ -125,7 +125,7 @@ return {root_, packageFile_, files_};
 
 
 
-export function build_(system_, emitTarget_, mainPackage_, mainModules_, resolvedDependencies_, compilerModulePath_, tempPath_, jsOutputPath_, printMeasurements_, moduleCache_) {
+export function build_(system_, emitTarget_, mainModules_, resolvedDependencies_, compilerModulePath_, tempPath_, jsOutputPath_, printMeasurements_, moduleCache_) {
 if(ff_core_Path.Path_exists(tempPath_, false, false, false)) {
 ff_core_Path.Path_delete(tempPath_, 0, 100)
 };
@@ -135,8 +135,8 @@ ff_core_Path.Path_createDirectory(jsPathFile_, true);
 const success_ = ff_core_Core.do_((() => {
 const compiler_ = ff_compiler_Compiler.new_(emitTarget_, ff_core_NodeSystem.NodeSystem_mainTask(system_), compilerModulePath_, jsPathFile_, resolvedDependencies_, ff_core_Map.new_(), moduleCache_, ff_compiler_LspHook.disabled_());
 for(let for_a = mainModules_, for_i = 0, for_l = for_a.length; for_i < for_l; for_i++) {
-const mainModule_ = for_a[for_i];
-ff_compiler_Compiler.Compiler_emit(compiler_, mainPackage_, mainModule_, true)
+const moduleKey_ = for_a[for_i];
+ff_compiler_Compiler.Compiler_emit(compiler_, moduleKey_, true)
 };
 if(printMeasurements_) {
 ff_compiler_Compiler.Compiler_printMeasurements(compiler_)
@@ -190,46 +190,41 @@ ff_core_NodeSystem.NodeSystem_writeErrorBuffer(system_, result_.standardError_)
 }
 
 export function buildViaBuildSystem_(system_, fireflyPath_, mainFiles_, target_) {
-const mainPaths_ = ff_core_List.List_map(mainFiles_, ((_w1) => {
-return ff_core_Path.Path_absolute(ff_core_Option.Option_grab(ff_core_Path.Path_parent(ff_core_NodeSystem.NodeSystem_path(system_, _w1))))
-}));
-{
-const if_o = ff_core_List.List_find(mainPaths_, ((_w1) => {
-return (_w1 !== ff_core_List.List_grabFirst(mainPaths_))
-}))
-if(if_o.Some) {
-const path_ = if_o.value_;
-ff_core_Core.panic_(((("Can't build multiple main files in different directories: " + path_) + " vs. ") + ff_core_List.List_grabFirst(mainPaths_)))
-}
-};
-const resolvedDependencies_ = ff_compiler_Dependencies.process_(ff_core_NodeSystem.NodeSystem_httpClient(system_), ff_compiler_DependencyLock.new_(ff_core_NodeSystem.NodeSystem_mainTask(system_)), ff_core_NodeSystem.NodeSystem_path(system_, ff_core_List.List_grabFirst(mainFiles_)));
+const resolvedDependencies_ = ff_compiler_Dependencies.process_(ff_core_NodeSystem.NodeSystem_httpClient(system_), ff_compiler_DependencyLock.new_(ff_core_NodeSystem.NodeSystem_mainTask(system_)), ff_core_List.List_grabFirst(mainFiles_));
 const fixedPackagePaths_ = (ff_core_Map.Map_contains(resolvedDependencies_.packagePaths_, ff_compiler_Syntax.PackagePair("ff", "core"), ff_compiler_Syntax.ff_core_Ordering_Order$ff_compiler_Syntax_PackagePair)
 ? resolvedDependencies_.packagePaths_
 : ff_core_Map.Map_add(resolvedDependencies_.packagePaths_, ff_compiler_Syntax.PackagePair("ff", "core"), ff_core_Path.Path_slash(fireflyPath_, "core"), ff_compiler_Syntax.ff_core_Ordering_Order$ff_compiler_Syntax_PackagePair));
+const packageRoot_ = ff_core_Map.Map_grab(resolvedDependencies_.packagePaths_, resolvedDependencies_.mainPackagePair_, ff_compiler_Syntax.ff_core_Ordering_Order$ff_compiler_Syntax_PackagePair);
+const mainModuleKeys_ = ff_core_List.List_map(mainFiles_, ((mainFile_) => {
+return ff_core_Option.Option_else(ff_compiler_Syntax.PackagePair_moduleKey(resolvedDependencies_.mainPackagePair_, packageRoot_, mainFile_), (() => {
+return ff_core_Core.panic_(((("Can't build multiple main files in different packages: " + ff_core_Path.Path_absolute(mainFile_)) + " isn't part of ") + ff_core_Path.Path_absolute(packageRoot_)))
+}))
+}));
 if((target_ !== "browser")) {
 ff_core_Core.panic_("buildViaBuildSystem is currently limited to browser target only - the restriction can be lifted")
 };
-ff_compiler_Builder.build_(system_, ff_compiler_JsEmitter.EmitBrowser(), resolvedDependencies_.mainPackagePair_, ff_core_List.List_map(mainFiles_, ((_w1) => {
-return ff_core_String.String_dropLast(_w1, ".ff".length)
-})), (((_c) => {
+ff_compiler_Builder.build_(system_, ff_compiler_JsEmitter.EmitBrowser(), mainModuleKeys_, (((_c) => {
 return ff_compiler_Dependencies.ResolvedDependencies(_c.mainPackagePair_, _c.packages_, fixedPackagePaths_, _c.singleFilePackages_)
 }))(resolvedDependencies_), ff_core_Option.None(), ff_core_NodeSystem.NodeSystem_path(system_, ".firefly/temporary"), ff_core_Path.Path_slash(ff_core_NodeSystem.NodeSystem_path(system_, ".firefly/output"), target_), false, ff_compiler_ModuleCache.new_(0))
 }
 
-export function check_(system_, fireflyPath_, path_, mustContain_, skipFiles_, virtualFiles_, cache_, dependencyLock_, newVersion_, lspHook_, infer_, checkDependencies_) {
+export function check_(system_, fireflyPath_, path_, mustContain_, skipFiles_, virtualFiles_, cache_, dependencyLock_, newVersion_, lspHook_, infer_) {
 const packages_ = (((_1) => {
-if(_1) {
-return ff_compiler_Builder.findPackageFiles_(path_, mustContain_, skipFiles_)
-}
 if(!_1 && ff_core_Path.Path_endsWith(path_, [".firefly", "package.ff"])) {
 return [ff_compiler_Builder.PackageFiles(ff_core_Option.Option_grab(ff_core_Path.Path_parent(path_)), ff_core_Option.Some(path_), [])]
 }
+if(_1) {
+return ff_compiler_Builder.findPackageFilesForDirectory_(path_, mustContain_, skipFiles_)
+}
 {
-return [ff_compiler_Builder.PackageFiles(ff_core_Option.Option_grab(ff_core_Path.Path_parent(path_)), ff_core_Option.None(), [path_])]
+return ff_core_Option.Option_toList(ff_compiler_Builder.findPackageFilesForFile_(path_))
 }
 }))(ff_core_Path.Path_isDirectory(path_));
 const errors_ = ff_core_Array.new_();
-for(let for_a = ff_core_List.List_filter(packages_, ((_w1) => {
+const filteredPackages_ = ff_core_List.List_filter(packages_, ((_w1) => {
+return (!ff_core_Path.Path_contains(_w1.root_, [".firefly", "dependencies"]))
+}));
+for(let for_a = ff_core_List.List_filter(filteredPackages_, ((_w1) => {
 return (!ff_core_List.List_isEmpty(_w1.files_))
 })), for_i = 0, for_l = for_a.length; for_i < for_l; for_i++) {
 const package_ = for_a[for_i];
@@ -262,19 +257,17 @@ return ff_compiler_Dependencies.ResolvedDependencies(_c.mainPackagePair_, _c.pac
 }))(resolvedDependencies_);
 const newCache_ = ff_compiler_ModuleCache.ModuleCache_without(cache_, newVersion_, path_);
 const compiler_ = ff_compiler_Compiler.new_(ff_compiler_JsEmitter.EmitBuild(), ff_core_NodeSystem.NodeSystem_mainTask(system_), ff_core_Option.None(), ff_core_Path.Path_slash(ff_core_Path.Path_slash(package_.root_, ".firefly"), "temporary"), fixedResolvedDependencies_, virtualFiles_, newCache_, lspHook_);
-const files_ = (checkDependencies_
-? package_.files_
-: ff_core_List.List_filter(package_.files_, ((_w1) => {
-return (!ff_core_Path.Path_contains(_w1, [".firefly", "dependencies"]))
-})));
-for(let for_a = files_, for_i = 0, for_l = for_a.length; for_i < for_l; for_i++) {
+for(let for_a = package_.files_, for_i = 0, for_l = for_a.length; for_i < for_l; for_i++) {
 const file_ = for_a[for_i];
-const localFile_ = ff_core_Path.Path_base(file_);
+const packagePair_ = resolvedDependencies_.mainPackagePair_;
+const folders_ = ff_core_Path.Path_relativeListTo(ff_core_Option.Option_grab(ff_core_Path.Path_parent(file_)), package_.root_);
+const name_ = ff_core_Option.Option_grab(ff_core_String.String_removeLast(ff_core_Path.Path_base(file_), ".ff"));
+const moduleKey_ = ff_compiler_Syntax.ModuleKey(packagePair_, folders_, name_);
 ff_core_Try.Try_catch(ff_core_Try.Try_tryCatch(ff_core_Core.try_((() => {
 if(infer_) {
-ff_compiler_Compiler.Compiler_infer(compiler_, resolvedDependencies_.mainPackagePair_, ff_core_String.String_dropLast(localFile_, ".ff".length))
+ff_compiler_Compiler.Compiler_infer(compiler_, moduleKey_)
 } else {
-ff_compiler_Compiler.Compiler_resolve(compiler_, resolvedDependencies_.mainPackagePair_, ff_core_String.String_dropLast(localFile_, ".ff".length))
+ff_compiler_Compiler.Compiler_resolve(compiler_, moduleKey_)
 }
 })), ((_1, _2) => {
 {
@@ -299,8 +292,31 @@ ff_compiler_ModuleCache.ModuleCache_mergeVersions(cache_, compiler_.cache_)
 return ff_core_Array.Array_drain(errors_)
 }
 
-export function findPackageFiles_(path_, mustContain_, skipFiles_) {
-const files_ = ff_compiler_Builder.findFireflyFiles_(path_, mustContain_, skipFiles_);
+export function findPackageFilesForFile_(file_) {
+if((ff_core_Path.Path_extension(file_) === ".ff")) {
+return ff_core_Option.Some((function() {
+let packageFile_ = ff_core_Option.None();
+let currentDirectory_ = ff_core_Path.Path_parent(file_);
+while(((!ff_core_Option.Option_isEmpty(currentDirectory_)) && ff_core_Option.Option_isEmpty(packageFile_))) {
+packageFile_ = ff_core_Option.Option_filter(ff_core_Option.Option_map(currentDirectory_, ((_w1) => {
+return ff_core_Path.Path_slash(ff_core_Path.Path_slash(_w1, ".firefly"), "package.ff")
+})), ((_w1) => {
+return ff_core_Path.Path_exists(_w1, false, false, false)
+}));
+currentDirectory_ = ff_core_Path.Path_parent(ff_core_Option.Option_grab(currentDirectory_))
+};
+const projectRoot_ = ff_core_Option.Option_else(ff_core_Option.Option_map(packageFile_, ((_w1) => {
+return ff_core_Option.Option_grab(ff_core_Path.Path_parent(ff_core_Option.Option_grab(ff_core_Path.Path_parent(_w1))))
+})), (() => {
+return ff_core_Option.Option_grab(ff_core_Path.Path_parent(file_))
+}));
+return ff_compiler_Builder.PackageFiles(projectRoot_, packageFile_, [file_])
+})())
+} else return ff_core_Option.None()
+}
+
+export function findPackageFilesForDirectory_(directory_, mustContain_, skipFiles_) {
+const files_ = ff_compiler_Builder.findFireflyFiles_(directory_, mustContain_, skipFiles_);
 const split_ = ff_core_List.List_partition(files_, ((_w1) => {
 return ff_core_Path.Path_endsWith(_w1, [".firefly", "package.ff"])
 }));
@@ -312,7 +328,8 @@ const files_ = ff_core_List.List_partition(singleFiles_, ((_w1) => {
 return ff_core_Path.Path_isInsideOf(_w1, projectRoot_)
 }));
 singleFiles_ = files_.second_;
-return ff_compiler_Builder.PackageFiles(projectRoot_, ff_core_Option.Some(packageFile_), files_.first_)
+const packageFiles_ = files_.first_;
+return ff_compiler_Builder.PackageFiles(projectRoot_, ff_core_Option.Some(packageFile_), packageFiles_)
 }));
 const singleFileProjects_ = ff_core_List.List_map(singleFiles_, ((file_) => {
 const projectRoot_ = ff_core_Option.Option_grab(ff_core_Path.Path_parent(file_));
@@ -325,21 +342,23 @@ export function findFireflyFiles_(path_, mustContain_, skipFiles_) {
 const split_ = ff_core_List.List_partition(ff_core_Stream.Stream_toList(ff_core_Path.Path_entries(path_)), ((_w1) => {
 return ff_core_Path.PathEntry_isDirectory(_w1)
 }));
-const directories_ = ff_core_List.List_filter(ff_core_List.List_map(split_.first_, ((_w1) => {
+const directories_ = split_.first_;
+const files_ = split_.second_;
+const relevantDirectories_ = ff_core_List.List_filter(ff_core_List.List_map(directories_, ((_w1) => {
 return ff_core_Path.PathEntry_path(_w1)
 })), ((_w1) => {
 return ff_core_String.String_all(ff_core_Path.Path_base(_w1), ((c_) => {
 return (((c_ === 46) || ff_core_Char.Char_isAsciiLower(c_)) || ff_core_Char.Char_isAsciiDigit(c_))
 }))
 }));
-const fireflyFiles_ = ff_core_List.List_filter(ff_core_List.List_map(split_.second_, ((_w1) => {
+const fireflyFiles_ = ff_core_List.List_filter(ff_core_List.List_map(files_, ((_w1) => {
 return ff_core_Path.PathEntry_path(_w1)
 })), ((file_) => {
 return (((ff_core_Path.Path_extension(file_) === ".ff") && (!ff_core_Set.Set_contains(skipFiles_, ff_core_Path.Path_absolute(file_), ff_core_Ordering.ff_core_Ordering_Order$ff_core_String_String))) && ff_core_Option.Option_all(mustContain_, ((s_) => {
 return ff_core_String.String_contains(ff_core_Path.Path_readText(file_), s_)
 })))
 }));
-return [...fireflyFiles_, ...ff_core_List.List_flatMap(directories_, ((_w1) => {
+return [...fireflyFiles_, ...ff_core_List.List_flatMap(relevantDirectories_, ((_w1) => {
 return ff_compiler_Builder.findFireflyFiles_(_w1, mustContain_, skipFiles_)
 }))]
 }
@@ -385,7 +404,7 @@ const pkg_ = import$0;
 pkg_.exec([packageFile_.absolutePath_, "--out-path", outputPath_.absolutePath_, "--target", ff_core_List.List_join(targets_, ",")])
 }
 
-export async function build_$(system_, emitTarget_, mainPackage_, mainModules_, resolvedDependencies_, compilerModulePath_, tempPath_, jsOutputPath_, printMeasurements_, moduleCache_, $task) {
+export async function build_$(system_, emitTarget_, mainModules_, resolvedDependencies_, compilerModulePath_, tempPath_, jsOutputPath_, printMeasurements_, moduleCache_, $task) {
 if((await ff_core_Path.Path_exists$(tempPath_, false, false, false, $task))) {
 (await ff_core_Path.Path_delete$(tempPath_, 0, 100, $task))
 };
@@ -395,8 +414,8 @@ const jsPathFile_ = (await ff_core_Path.Path_slash$(tempPath_, "js", $task));
 const success_ = (await ff_core_Core.do_$((async ($task) => {
 const compiler_ = (await ff_compiler_Compiler.new_$(emitTarget_, (await ff_core_NodeSystem.NodeSystem_mainTask$(system_, $task)), compilerModulePath_, jsPathFile_, resolvedDependencies_, ff_core_Map.new_(), moduleCache_, ff_compiler_LspHook.disabled_(), $task));
 for(let for_a = mainModules_, for_i = 0, for_l = for_a.length; for_i < for_l; for_i++) {
-const mainModule_ = for_a[for_i];
-(await ff_compiler_Compiler.Compiler_emit$(compiler_, mainPackage_, mainModule_, true, $task))
+const moduleKey_ = for_a[for_i];
+(await ff_compiler_Compiler.Compiler_emit$(compiler_, moduleKey_, true, $task))
 };
 if(printMeasurements_) {
 (await ff_compiler_Compiler.Compiler_printMeasurements$(compiler_, $task))
@@ -450,46 +469,41 @@ if((result_.exitCode_ !== 0)) {
 }
 
 export async function buildViaBuildSystem_$(system_, fireflyPath_, mainFiles_, target_, $task) {
-const mainPaths_ = (await ff_core_List.List_map$(mainFiles_, (async (_w1, $task) => {
-return (await ff_core_Path.Path_absolute$(ff_core_Option.Option_grab((await ff_core_Path.Path_parent$((await ff_core_NodeSystem.NodeSystem_path$(system_, _w1, $task)), $task))), $task))
-}), $task));
-{
-const if_o = ff_core_List.List_find(mainPaths_, ((_w1) => {
-return (_w1 !== ff_core_List.List_grabFirst(mainPaths_))
-}))
-if(if_o.Some) {
-const path_ = if_o.value_;
-ff_core_Core.panic_(((("Can't build multiple main files in different directories: " + path_) + " vs. ") + ff_core_List.List_grabFirst(mainPaths_)))
-}
-};
-const resolvedDependencies_ = (await ff_compiler_Dependencies.process_$((await ff_core_NodeSystem.NodeSystem_httpClient$(system_, $task)), (await ff_compiler_DependencyLock.new_$((await ff_core_NodeSystem.NodeSystem_mainTask$(system_, $task)), $task)), (await ff_core_NodeSystem.NodeSystem_path$(system_, ff_core_List.List_grabFirst(mainFiles_), $task)), $task));
+const resolvedDependencies_ = (await ff_compiler_Dependencies.process_$((await ff_core_NodeSystem.NodeSystem_httpClient$(system_, $task)), (await ff_compiler_DependencyLock.new_$((await ff_core_NodeSystem.NodeSystem_mainTask$(system_, $task)), $task)), ff_core_List.List_grabFirst(mainFiles_), $task));
 const fixedPackagePaths_ = (ff_core_Map.Map_contains(resolvedDependencies_.packagePaths_, ff_compiler_Syntax.PackagePair("ff", "core"), ff_compiler_Syntax.ff_core_Ordering_Order$ff_compiler_Syntax_PackagePair)
 ? resolvedDependencies_.packagePaths_
 : ff_core_Map.Map_add(resolvedDependencies_.packagePaths_, ff_compiler_Syntax.PackagePair("ff", "core"), (await ff_core_Path.Path_slash$(fireflyPath_, "core", $task)), ff_compiler_Syntax.ff_core_Ordering_Order$ff_compiler_Syntax_PackagePair));
+const packageRoot_ = ff_core_Map.Map_grab(resolvedDependencies_.packagePaths_, resolvedDependencies_.mainPackagePair_, ff_compiler_Syntax.ff_core_Ordering_Order$ff_compiler_Syntax_PackagePair);
+const mainModuleKeys_ = (await ff_core_List.List_map$(mainFiles_, (async (mainFile_, $task) => {
+return (await ff_core_Option.Option_else$((await ff_compiler_Syntax.PackagePair_moduleKey$(resolvedDependencies_.mainPackagePair_, packageRoot_, mainFile_, $task)), (async ($task) => {
+return ff_core_Core.panic_(((("Can't build multiple main files in different packages: " + (await ff_core_Path.Path_absolute$(mainFile_, $task))) + " isn't part of ") + (await ff_core_Path.Path_absolute$(packageRoot_, $task))))
+}), $task))
+}), $task));
 if((target_ !== "browser")) {
 ff_core_Core.panic_("buildViaBuildSystem is currently limited to browser target only - the restriction can be lifted")
 };
-(await ff_compiler_Builder.build_$(system_, ff_compiler_JsEmitter.EmitBrowser(), resolvedDependencies_.mainPackagePair_, ff_core_List.List_map(mainFiles_, ((_w1) => {
-return ff_core_String.String_dropLast(_w1, ".ff".length)
-})), (((_c) => {
+(await ff_compiler_Builder.build_$(system_, ff_compiler_JsEmitter.EmitBrowser(), mainModuleKeys_, (((_c) => {
 return ff_compiler_Dependencies.ResolvedDependencies(_c.mainPackagePair_, _c.packages_, fixedPackagePaths_, _c.singleFilePackages_)
 }))(resolvedDependencies_), ff_core_Option.None(), (await ff_core_NodeSystem.NodeSystem_path$(system_, ".firefly/temporary", $task)), (await ff_core_Path.Path_slash$((await ff_core_NodeSystem.NodeSystem_path$(system_, ".firefly/output", $task)), target_, $task)), false, ff_compiler_ModuleCache.new_(0), $task))
 }
 
-export async function check_$(system_, fireflyPath_, path_, mustContain_, skipFiles_, virtualFiles_, cache_, dependencyLock_, newVersion_, lspHook_, infer_, checkDependencies_, $task) {
+export async function check_$(system_, fireflyPath_, path_, mustContain_, skipFiles_, virtualFiles_, cache_, dependencyLock_, newVersion_, lspHook_, infer_, $task) {
 const packages_ = (await ((async (_1, $task) => {
-if(_1) {
-return (await ff_compiler_Builder.findPackageFiles_$(path_, mustContain_, skipFiles_, $task))
-}
 if(!_1 && (await ff_core_Path.Path_endsWith$(path_, [".firefly", "package.ff"], $task))) {
 return [ff_compiler_Builder.PackageFiles(ff_core_Option.Option_grab((await ff_core_Path.Path_parent$(path_, $task))), ff_core_Option.Some(path_), [])]
 }
+if(_1) {
+return (await ff_compiler_Builder.findPackageFilesForDirectory_$(path_, mustContain_, skipFiles_, $task))
+}
 {
-return [ff_compiler_Builder.PackageFiles(ff_core_Option.Option_grab((await ff_core_Path.Path_parent$(path_, $task))), ff_core_Option.None(), [path_])]
+return ff_core_Option.Option_toList((await ff_compiler_Builder.findPackageFilesForFile_$(path_, $task)))
 }
 }))((await ff_core_Path.Path_isDirectory$(path_, $task)), $task));
 const errors_ = ff_core_Array.new_();
-for(let for_a = ff_core_List.List_filter(packages_, ((_w1) => {
+const filteredPackages_ = (await ff_core_List.List_filter$(packages_, (async (_w1, $task) => {
+return (!(await ff_core_Path.Path_contains$(_w1.root_, [".firefly", "dependencies"], $task)))
+}), $task));
+for(let for_a = ff_core_List.List_filter(filteredPackages_, ((_w1) => {
 return (!ff_core_List.List_isEmpty(_w1.files_))
 })), for_i = 0, for_l = for_a.length; for_i < for_l; for_i++) {
 const package_ = for_a[for_i];
@@ -522,19 +536,17 @@ return ff_compiler_Dependencies.ResolvedDependencies(_c.mainPackagePair_, _c.pac
 }))(resolvedDependencies_);
 const newCache_ = (await ff_compiler_ModuleCache.ModuleCache_without$(cache_, newVersion_, path_, $task));
 const compiler_ = (await ff_compiler_Compiler.new_$(ff_compiler_JsEmitter.EmitBuild(), (await ff_core_NodeSystem.NodeSystem_mainTask$(system_, $task)), ff_core_Option.None(), (await ff_core_Path.Path_slash$((await ff_core_Path.Path_slash$(package_.root_, ".firefly", $task)), "temporary", $task)), fixedResolvedDependencies_, virtualFiles_, newCache_, lspHook_, $task));
-const files_ = (checkDependencies_
-? package_.files_
-: (await ff_core_List.List_filter$(package_.files_, (async (_w1, $task) => {
-return (!(await ff_core_Path.Path_contains$(_w1, [".firefly", "dependencies"], $task)))
-}), $task)));
-for(let for_a = files_, for_i = 0, for_l = for_a.length; for_i < for_l; for_i++) {
+for(let for_a = package_.files_, for_i = 0, for_l = for_a.length; for_i < for_l; for_i++) {
 const file_ = for_a[for_i];
-const localFile_ = (await ff_core_Path.Path_base$(file_, $task));
+const packagePair_ = resolvedDependencies_.mainPackagePair_;
+const folders_ = (await ff_core_Path.Path_relativeListTo$(ff_core_Option.Option_grab((await ff_core_Path.Path_parent$(file_, $task))), package_.root_, $task));
+const name_ = ff_core_Option.Option_grab(ff_core_String.String_removeLast((await ff_core_Path.Path_base$(file_, $task)), ".ff"));
+const moduleKey_ = ff_compiler_Syntax.ModuleKey(packagePair_, folders_, name_);
 ff_core_Try.Try_catch(ff_core_Try.Try_tryCatch((await ff_core_Core.try_$((async ($task) => {
 if(infer_) {
-(await ff_compiler_Compiler.Compiler_infer$(compiler_, resolvedDependencies_.mainPackagePair_, ff_core_String.String_dropLast(localFile_, ".ff".length), $task))
+(await ff_compiler_Compiler.Compiler_infer$(compiler_, moduleKey_, $task))
 } else {
-(await ff_compiler_Compiler.Compiler_resolve$(compiler_, resolvedDependencies_.mainPackagePair_, ff_core_String.String_dropLast(localFile_, ".ff".length), $task))
+(await ff_compiler_Compiler.Compiler_resolve$(compiler_, moduleKey_, $task))
 }
 }), $task)), ((_1, _2) => {
 {
@@ -559,8 +571,31 @@ ff_compiler_ModuleCache.ModuleCache_mergeVersions(cache_, compiler_.cache_)
 return ff_core_Array.Array_drain(errors_)
 }
 
-export async function findPackageFiles_$(path_, mustContain_, skipFiles_, $task) {
-const files_ = (await ff_compiler_Builder.findFireflyFiles_$(path_, mustContain_, skipFiles_, $task));
+export async function findPackageFilesForFile_$(file_, $task) {
+if(((await ff_core_Path.Path_extension$(file_, $task)) === ".ff")) {
+return ff_core_Option.Some((await (async function() {
+let packageFile_ = ff_core_Option.None();
+let currentDirectory_ = (await ff_core_Path.Path_parent$(file_, $task));
+while(((!ff_core_Option.Option_isEmpty(currentDirectory_)) && ff_core_Option.Option_isEmpty(packageFile_))) {
+packageFile_ = (await ff_core_Option.Option_filter$((await ff_core_Option.Option_map$(currentDirectory_, (async (_w1, $task) => {
+return (await ff_core_Path.Path_slash$((await ff_core_Path.Path_slash$(_w1, ".firefly", $task)), "package.ff", $task))
+}), $task)), (async (_w1, $task) => {
+return (await ff_core_Path.Path_exists$(_w1, false, false, false, $task))
+}), $task));
+currentDirectory_ = (await ff_core_Path.Path_parent$(ff_core_Option.Option_grab(currentDirectory_), $task))
+};
+const projectRoot_ = (await ff_core_Option.Option_else$((await ff_core_Option.Option_map$(packageFile_, (async (_w1, $task) => {
+return ff_core_Option.Option_grab((await ff_core_Path.Path_parent$(ff_core_Option.Option_grab((await ff_core_Path.Path_parent$(_w1, $task))), $task)))
+}), $task)), (async ($task) => {
+return ff_core_Option.Option_grab((await ff_core_Path.Path_parent$(file_, $task)))
+}), $task));
+return ff_compiler_Builder.PackageFiles(projectRoot_, packageFile_, [file_])
+})()))
+} else return ff_core_Option.None()
+}
+
+export async function findPackageFilesForDirectory_$(directory_, mustContain_, skipFiles_, $task) {
+const files_ = (await ff_compiler_Builder.findFireflyFiles_$(directory_, mustContain_, skipFiles_, $task));
 const split_ = (await ff_core_List.List_partition$(files_, (async (_w1, $task) => {
 return (await ff_core_Path.Path_endsWith$(_w1, [".firefly", "package.ff"], $task))
 }), $task));
@@ -572,7 +607,8 @@ const files_ = (await ff_core_List.List_partition$(singleFiles_, (async (_w1, $t
 return (await ff_core_Path.Path_isInsideOf$(_w1, projectRoot_, $task))
 }), $task));
 singleFiles_ = files_.second_;
-return ff_compiler_Builder.PackageFiles(projectRoot_, ff_core_Option.Some(packageFile_), files_.first_)
+const packageFiles_ = files_.first_;
+return ff_compiler_Builder.PackageFiles(projectRoot_, ff_core_Option.Some(packageFile_), packageFiles_)
 }), $task));
 const singleFileProjects_ = (await ff_core_List.List_map$(singleFiles_, (async (file_, $task) => {
 const projectRoot_ = ff_core_Option.Option_grab((await ff_core_Path.Path_parent$(file_, $task)));
@@ -585,21 +621,23 @@ export async function findFireflyFiles_$(path_, mustContain_, skipFiles_, $task)
 const split_ = (await ff_core_List.List_partition$((await ff_core_Stream.Stream_toList$((await ff_core_Path.Path_entries$(path_, $task)), $task)), (async (_w1, $task) => {
 return (await ff_core_Path.PathEntry_isDirectory$(_w1, $task))
 }), $task));
-const directories_ = (await ff_core_List.List_filter$((await ff_core_List.List_map$(split_.first_, (async (_w1, $task) => {
+const directories_ = split_.first_;
+const files_ = split_.second_;
+const relevantDirectories_ = (await ff_core_List.List_filter$((await ff_core_List.List_map$(directories_, (async (_w1, $task) => {
 return (await ff_core_Path.PathEntry_path$(_w1, $task))
 }), $task)), (async (_w1, $task) => {
 return ff_core_String.String_all((await ff_core_Path.Path_base$(_w1, $task)), ((c_) => {
 return (((c_ === 46) || ff_core_Char.Char_isAsciiLower(c_)) || ff_core_Char.Char_isAsciiDigit(c_))
 }))
 }), $task));
-const fireflyFiles_ = (await ff_core_List.List_filter$((await ff_core_List.List_map$(split_.second_, (async (_w1, $task) => {
+const fireflyFiles_ = (await ff_core_List.List_filter$((await ff_core_List.List_map$(files_, (async (_w1, $task) => {
 return (await ff_core_Path.PathEntry_path$(_w1, $task))
 }), $task)), (async (file_, $task) => {
 return ((((await ff_core_Path.Path_extension$(file_, $task)) === ".ff") && (!ff_core_Set.Set_contains(skipFiles_, (await ff_core_Path.Path_absolute$(file_, $task)), ff_core_Ordering.ff_core_Ordering_Order$ff_core_String_String))) && (await ff_core_Option.Option_all$(mustContain_, (async (s_, $task) => {
 return ff_core_String.String_contains((await ff_core_Path.Path_readText$(file_, $task)), s_)
 }), $task)))
 }), $task));
-return [...fireflyFiles_, ...(await ff_core_List.List_flatMap$(directories_, (async (_w1, $task) => {
+return [...fireflyFiles_, ...(await ff_core_List.List_flatMap$(relevantDirectories_, (async (_w1, $task) => {
 return (await ff_compiler_Builder.findFireflyFiles_$(_w1, mustContain_, skipFiles_, $task))
 }), $task))]
 }