firefly-compiler 0.5.50 → 0.5.51

package/fireflysite/RouteFront.ff

@@ -0,0 +1,30 @@
+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()
+
+data PageData(sections: List[Section])
+
+handle(request: WebRequest[WebResponse], context: RouteContext) {
+    let pageData = PageData(FrontPage.sections())
+    let title = "Firefly"
+    Html.renderAndServe(context.system, routeModule, pageData, title, request, {render(_, pageData)})
+}
+
+browserMain(system: BrowserSystem) {
+    Html.renderToMain(system, {render(_, _)})
+}
+
+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())
+    }
+}

package/fireflysite/RouteNonMarkdown.ff

@@ -0,0 +1,48 @@
+import Lux from ff:lux
+import WebServer from ff:webserver
+import Router
+import Guide
+import ExamplesOverview
+import GettingStarted
+import CountingButtonDemo
+import MatchingPasswordsDemo
+import PostgresqlDemo
+import Html
+import Website
+import Menu
+import PackagesOverview
+import CommunityOverview
+
+routeModule = SourceLocation.here().module()
+
+data PageData(menuEntry: MenuItem, sections: List[Section])
+
+handle(request: WebRequest[WebResponse], context: RouteContext, directory: String, name: Option[String]) {
+    let path = [directory, ...name.toList()]
+    Menu.findItem(path).or {Html.serve404(request)}: menuEntry => 
+    
+    let sections = path.{
+        | ["getting-started"] => GettingStarted.sections()
+        | ["examples"] => ExamplesOverview.sections()
+        | ["examples", "counting-button"] => CountingButtonDemo.sections()
+        | ["examples", "matching-passwords"] => MatchingPasswordsDemo.sections()
+        | ["examples", "connecting-to-postgresql"] => PostgresqlDemo.sections()
+        | ["packages"] => PackagesOverview.sections()
+        | ["community"] => CommunityOverview.sections()
+        | _ => []
+    }
+    if(sections.isEmpty()) {Html.serve404(request)} else:
+    let pageData = PageData(menuEntry, sections)
+    let title = Html.title(menuEntry)
+    Html.renderAndServe(context.system, routeModule, pageData, title, request, {render(_, pageData)})
+}
+
+browserMain(system: BrowserSystem) {
+    Html.renderToMain(system, {render(_, _)})
+}
+
+render(lux: Lux, data: PageData) {
+    Website.renderContentWithNext(lux, data.menuEntry.path, data.menuEntry.next) {lux =>
+        Guide.renderSections(lux, data.sections, ExamplesOverview.demos())
+    }
+}

package/fireflysite/RouteReference.ff

@@ -0,0 +1,40 @@
+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()
+
+data PageData(menuEntry: MenuItem, sections: List[Section])
+
+handle(request: WebRequest[WebResponse], context: RouteContext, kebab: Option[String]) {
+    let path = ["reference", ...kebab.toList()]
+    Menu.findItem(path).or {Html.serve404(request)}: menuEntry => 
+    
+    let asset = "/assets/markdown/" + path.join("/") + ".md"
+    try {context.system.assets().readText(asset)}.toOption().or {
+        Log.trace("Asset not found: " + asset)
+        Html.serve404(request)
+    }: markdown =>
+    let parser = DocumentParser(path.last().grab(), markdown.split('\n'), 0)
+    let sections = parser.parseDocument()
+    let pageData = PageData(menuEntry, sections)
+    let title = Html.title(menuEntry)
+    Html.renderAndServe(context.system, routeModule, pageData, title, request, {render(_, pageData)})
+}
+
+browserMain(system: BrowserSystem) {
+    Html.renderToMain(system, {render(_, _)})
+}
+
+render(lux: Lux, data: PageData) {
+    Website.renderContentWithNext(lux, data.menuEntry.path, data.menuEntry.next) {lux =>
+        Guide.renderSections(lux, data.sections, ExamplesOverview.demos())
+    }
+}

package/fireflysite/Router.ff

@@ -0,0 +1,33 @@
+import WebServer from ff:webserver
+import WebRoute from ff:webserver
+import RouteFront
+import RouteReference
+import RouteNonMarkdown
+
+capability RouteContext(system: NodeSystem)
+
+frontRoute: WebRoute0 = WebRoute.new0(
+    "/"
+)
+
+referenceRoute: WebRoute1[Option[String]] = WebRoute.new1(
+    "/reference/{name?}"
+)
+
+nonMarkdownRoute: WebRoute2[String, Option[String]] = WebRoute.new2(
+    "/{directory}/{name?}"
+)
+
+modulesWithBrowserMain(): List[String] {
+    [
+        RouteFront.routeModule
+        RouteReference.routeModule
+        RouteNonMarkdown.routeModule
+    ]
+}
+
+handlers(handler: WebRouteHandler[RouteContext]) {
+    handler.add0(frontRoute, RouteFront.handle)
+    handler.add1(referenceRoute, RouteReference.handle)
+    handler.add2(nonMarkdownRoute, RouteNonMarkdown.handle)
+}

package/fireflysite/Website.ff

@@ -0,0 +1,133 @@
+import Lux from ff:lux
+import LuxEvent from ff:lux
+import Css from ff:lux
+import Styles
+import Menu
+
+renderContentWithNext(
+    lux: Lux
+    path: List[String]
+    next: Option[MenuItem]
+    content: Lux => Unit
+) {
+    lux.add("div") {
+        lux.useState(False): showMenu, setMenu =>
+        lux.cssClass(Styles.pageCss)
+        lux.add("div") {
+            lux.cssClass(Styles.guideCss)
+            lux.add("main") {
+                lux.cssClass(Styles.guideMainCss)
+                lux.add("article") {
+                    lux.cssClass(Styles.guideDocumentCss)
+                    content(lux)
+                    renderNext(lux, next)
+                }
+            }
+            renderTopbar(lux, showMenu, setMenu)
+            lux.add("div") {
+                lux.cssClass(Styles.guideSidebarBackdropCss)
+                if(showMenu) {lux.cssClass(Styles.guideSidebarBackdropOpenCss)}
+                lux.onClick {event =>
+                    event.preventDefault()
+                    setMenu(False)
+                }
+            }
+            renderSidebar(lux, path, showMenu)
+        }
+    }
+}
+
+renderNext(lux: Lux, nextItem: Option[MenuItem]) {
+    nextItem.each {next => 
+        lux.div {
+            lux.cssClass(Styles.guideNextButtonCss)
+            lux.add("a") {
+                lux.cssClass(Styles.guideButtonCss)
+                lux.set("href", "/" + next.path.join("/"))
+                lux.text("Next: " + next.name)
+            }
+        }
+    }
+}
+
+renderTopbar(lux: Lux, showMenu: Bool, setMenu: Bool => Unit) {
+    lux.add("div") {
+        lux.cssClass(Styles.guideTopbarCss)
+        lux.add("a") {
+            lux.set("href", "/")
+            lux.cssClass(Styles.guideTopbarLogoCss)
+            lux.add("img") {
+                lux.set("src", "/assets/image/firefly-logo-yellow.webp")
+            }
+            lux.div {
+                lux.text("Firefly")
+            }
+        }
+        lux.add("button") {
+            lux.set("aria-label", "Toggle the menu")
+            lux.cssClass(Styles.guideTopbarButtonCss)
+            lux.onClick {event =>
+                event.preventDefault()
+                setMenu(True)
+            }
+        }
+    }
+}
+
+renderSidebar(lux: Lux, selectedPath: List[String], showMenu: Bool) {
+    lux.add("nav") {
+        lux.cssClass(Styles.guideSidebarCss)
+        if(showMenu) {lux.cssClass(Styles.guideSidebarOpenCss)}
+        lux.add("a") {
+            lux.set("href", "/")
+            lux.cssClass(Styles.guideSidebarLogoCss)
+            lux.add("img") {
+                lux.set("src", "/assets/image/firefly-logo-yellow.webp")
+            }
+            lux.div {
+                lux.text("Firefly")
+            }
+        }
+        lux.add("form") {
+            lux.set("role", "search")
+            lux.add("input") {
+                lux.set("aria-label", "Search")
+                lux.cssClass(Styles.searchInputCss)
+                lux.set("placeholder", "Search...")
+            }
+        }
+        lux.add("ul") {
+            lux.cssClass(Styles.guideSidebarUl1Css)
+            Menu.menu.each {item =>
+                lux.add("li") {
+                    lux.cssClass(Styles.guideSidebarLi1Css)
+                    lux.add("a") {
+                        lux.cssClass(Styles.whiteLinkCss)
+                        if(selectedPath == [item.path]) {
+                            lux.set("aria-current", "page")
+                        }
+                        lux.set("href", "/" + item.path)
+                        lux.text(item.name)
+                    }
+                    if(item.menu.size() > 1):
+                    lux.add("ul") {
+                        lux.cssClass(Styles.guideSidebarUl2Css)
+                        item.menu.each {subItem =>
+                            lux.add("li") {
+                                lux.cssClass(Styles.guideSidebarLi2Css)
+                                lux.add("a") {
+                                    lux.cssClass(Styles.whiteLinkCss)
+                                    if(selectedPath == [item.path, subItem.path]) {
+                                        lux.set("aria-current", "page")
+                                    }
+                                    lux.set("href", "/" + item.path + "/" + subItem.path)
+                                    lux.text(subItem.name)
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+}

package/fireflysite/assets/markdown/reference/{FunctionsAndMethods.md → functions-and-methods.md}

@@ -362,4 +362,4 @@ Some(1).map {_ + 1} // Some(2)
 
 # Trait functions
  
-Trait functions are covered in the section about [traits and instances](traits-and-instances)
+Trait functions are covered in the section about [traits and instances](traits-and-instances)

package/fireflysite/assets/markdown/reference/{StatementsAndExpressions.md → statements-and-expressions.md}

@@ -83,4 +83,3 @@ Binary operators are left associative and the operator precedence is as follows,
  * `x.y` `x.V()` `x.{_}`
 
 Unary operators `!` and `-` have higher precedence than `^` and lower precedence than `f()`.
-

package/fireflysite/assets/markdown/reference/{StructuredConcurrency.md → structured-concurrency.md}

@@ -96,4 +96,3 @@ However, there are two problems here:
 
  * If all the fetch tasks are waiting to write to the `out` channel, `in.write(url)` will block forever.
  * There's no logic to discover that there are no API calls left to do, so the `total` will never be reported.
- 

package/fireflysite/assets/markdown/reference.md

@@ -0,0 +1,3 @@
+# Reference
+
+This is a reference for the Firefly programming language.

package/graph/.firefly/package.ff

@@ -0,0 +1 @@
+package ff:graph:0.0.0

package/graph/Graph.ff

@@ -0,0 +1,79 @@
+/*nodeMain(system: NodeSystem) {
+    let result = tarjan([1]) {
+        | 1, f => f(2); f(3); f(4)
+        | 2, f => f(5)
+        | 5, f => f(2)
+        | 3, f => f(6); f(7)
+        | 4, f => f(8)
+        | 8, f => f(9); f(10)
+        | 9, f => f(11); f(10)
+        | 10, f => f(8); f(9)
+        | _, f => 
+    }
+    Log.show(result)
+}*/
+
+breadthFirst(roots: List[Int], eachEdge: (Int, Int => Unit) => Unit): Unit {
+    mutable seen = IntMap.new()
+    let queue = Array.new()
+    queue.pushList(roots)
+    mutable i = 0
+    while {i < queue.size()} {
+        eachEdge(queue.grab(i)) {v =>
+            if(!seen.has(v)) {
+                seen.set(v, v)
+                queue.push(v)
+            }
+        }
+        i += 1
+    }
+}
+
+tarjan(roots: List[Int], eachEdge: (Int, Int => Unit) => Unit): List[List[Int]] {
+    mutable index = 0
+    mutable stack = Array.new[Int]()
+    mutable onStack = IntMap.new[Bool]()
+    mutable indices = IntMap.new[Int]()
+    mutable lowlink = IntMap.new[Int]()
+    mutable sccs = Array.new[List[Int]]()
+
+    function go(v: Int) {
+        indices.set(v, index)
+        lowlink.set(v, index)
+        index += 1
+
+        stack.push(v)
+        onStack.set(v, True)
+
+        eachEdge(v) {w =>
+            if(!indices.has(w)) {
+                go(w)
+                lowlink.set(v, lowlink.grab(v).min(lowlink.grab(w)))
+            } elseIf {onStack.grab(w)} {
+                lowlink.set(v, lowlink.grab(v).min(indices.grab(w)))
+            }
+        }
+
+        if(lowlink.grab(v) == indices.grab(v)) {
+            let scc = Array.new[Int]()
+            mutable done = False
+            while {!done} {
+                let w = stack.pop().grab()
+                onStack.set(w, False)
+                scc.push(w)
+                if(w == v) {
+                    done = True
+                }
+            }
+            sccs.push(scc.drain())
+        }
+    }
+
+    roots.each {v =>
+        if(!indices.has(v)) {
+            go(v)
+        }
+    }
+
+    sccs.drain()
+}

package/lsp/CompletionHandler.ff

@@ -792,8 +792,8 @@ toplevelCompletion(lspHook: LspHook): List[CompletionInfo] {
                 "}"
                 ""
                 "buildMain(system: BuildSystem) {"
-                "    let browser = system.compileForBrowser(\"$TM_FILENAME_BASE.ff\")"
-                "    let assets = AssetSystem.create().addAssets(\"/js\", browser.assets())"
+                "    let browserAssets = system.compileForBrowser([\"$TM_FILENAME_BASE.ff\"])"
+                "    let assets = AssetSystem.create().addAssets(\"/js\", browserAssets)"
                 "    system.setAssets(assets)"
                 "}"
             ].join("\n"), 

package/lux/CssTest.ff

@@ -42,7 +42,7 @@ nodeMain(system: NodeSystem) {
 }
 
 buildMain(system: BuildSystem) {
-    let browser = system.compileForBrowser("CssTest.ff")
-    let assets = AssetSystem.create().addAssets("/js", browser.assets())
+    let browserAssets = system.compileForBrowser(["CssTest.ff"])
+    let assets = AssetSystem.create().addAssets("/js", browserAssets)
     system.setAssets(assets)
 }

package/lux/Main.ff

@@ -117,7 +117,7 @@ in E.object
 ]
 */
 buildMain(system: BuildSystem) {
-    let browser = system.compileForBrowser("Main.ff")
-    let assets = AssetSystem.create().addAssets("/js", browser.assets())
+    let browserAssets = system.compileForBrowser(["Main.ff"])
+    let assets = AssetSystem.create().addAssets("/js", browserAssets)
     system.setAssets(assets)
 }

package/lux/Main2.ff

@@ -125,8 +125,8 @@ nodeMain(system: NodeSystem): Unit {
 }
 
 buildMain(system: BuildSystem) {
-    let browser = system.compileForBrowser("Main2.ff")
-    let assets = AssetSystem.create().addAssets("/js", browser.assets())
+    let browserAssets = system.compileForBrowser(["Main2.ff"])
+    let assets = AssetSystem.create().addAssets("/js", browserAssets)
     system.setAssets(assets)
 }
 

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

@@ -125,7 +125,7 @@ return {root_, packageFile_, files_};
 
 
 
-export function build_(system_, emitTarget_, mainPackage_, mainModule_, resolvedDependencies_, compilerModulePath_, tempPath_, jsOutputPath_, printMeasurements_, moduleCache_) {
+export function build_(system_, emitTarget_, mainPackage_, 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)
 };
@@ -134,7 +134,10 @@ const jsPathFile_ = ff_core_Path.Path_slash(tempPath_, "js");
 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_());
-ff_compiler_Compiler.Compiler_emit(compiler_, mainPackage_, mainModule_, true);
+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)
+};
 if(printMeasurements_) {
 ff_compiler_Compiler.Compiler_printMeasurements(compiler_)
 };
@@ -186,15 +189,29 @@ ff_core_NodeSystem.NodeSystem_writeErrorBuffer(system_, result_.standardError_)
 }
 }
 
-export function buildViaBuildSystem_(system_, fireflyPath_, mainFile_, target_) {
-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_, mainFile_));
+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 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));
 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_String.String_dropLast(mainFile_, ".ff".length), (((_c) => {
+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) => {
 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))
 }
@@ -368,7 +385,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_, mainModule_, resolvedDependencies_, compilerModulePath_, tempPath_, jsOutputPath_, printMeasurements_, moduleCache_, $task) {
+export async function build_$(system_, emitTarget_, mainPackage_, 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))
 };
@@ -377,7 +394,10 @@ const jsPathFile_ = (await ff_core_Path.Path_slash$(tempPath_, "js", $task));
 (await ff_core_Path.Path_createDirectory$(jsPathFile_, true, $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));
-(await ff_compiler_Compiler.Compiler_emit$(compiler_, mainPackage_, mainModule_, true, $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))
+};
 if(printMeasurements_) {
 (await ff_compiler_Compiler.Compiler_printMeasurements$(compiler_, $task))
 };
@@ -429,15 +449,29 @@ if((result_.exitCode_ !== 0)) {
 }
 }
 
-export async function buildViaBuildSystem_$(system_, fireflyPath_, mainFile_, target_, $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)), (await ff_core_NodeSystem.NodeSystem_path$(system_, mainFile_, $task)), $task));
+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 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));
 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_String.String_dropLast(mainFile_, ".ff".length), (((_c) => {
+(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) => {
 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))
 }
@@ -614,5 +648,3 @@ const pkg_ = import$0;
 
 
 
-
-

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

@@ -264,7 +264,7 @@ return ff_compiler_Dictionaries.Dictionaries_processModule(ff_compiler_Dictionar
 }
 
 export function Compiler_emit(self_, packagePair_, moduleName_, isMainModule_) {
-ff_compiler_ModuleCache.ModuleCache_cacheEmittedModule(self_.cache_, self_.packagePaths_, packagePair_, moduleName_, ((path_) => {
+ff_compiler_ModuleCache.ModuleCache_cacheEmittedModule(self_.cache_, self_.packagePaths_, packagePair_, moduleName_, isMainModule_, ((path_) => {
 ff_compiler_Compiler.Compiler_measure(self_, "Emit", packagePair_, moduleName_, (() => {
 const module_ = ff_compiler_Compiler.Compiler_infer(self_, packagePair_, moduleName_);
 const otherModules_ = ff_core_List.List_map(ff_compiler_Compiler.Compiler_imports(self_, module_), ((i_) => {
@@ -273,13 +273,23 @@ ff_compiler_Compiler.Compiler_emit(self_, i_.packagePair_, newModuleName_, false
 return ff_compiler_Compiler.Compiler_infer(self_, i_.packagePair_, newModuleName_)
 }));
 const allModules_ = [module_, ...otherModules_];
-const js_ = ff_compiler_JsEmitter.JsEmitter_emitModule(ff_compiler_JsEmitter.new_(allModules_, self_.emitTarget_, isMainModule_, ff_core_Option.Option_map(self_.compilerModulePath_, ((_w1) => {
+const emitter_ = ff_compiler_JsEmitter.new_(allModules_, self_.emitTarget_, isMainModule_, ff_core_Option.Option_map(self_.compilerModulePath_, ((_w1) => {
 return ff_core_Path.Path_url(_w1)
-})), packagePair_, moduleName_), packagePair_, module_);
+})), packagePair_, moduleName_);
+const js_ = ff_compiler_JsEmitter.JsEmitter_emitModule(emitter_, packagePair_, module_);
 const jsPath_ = ff_core_Path.Path_slash(ff_core_Path.Path_slash(self_.jsOutputPath_, packagePair_.group_), packagePair_.name_);
 const jsFile_ = ff_core_Path.Path_slash(jsPath_, (moduleName_ + ".mjs"));
 ff_core_Path.Path_createDirectory(jsPath_, true);
-return ff_core_Path.Path_writeText(jsFile_, js_)
+ff_core_Path.Path_writeText(jsFile_, js_);
+if(isMainModule_) {
+return ff_core_Option.Some((function() {
+const runJs_ = ff_compiler_JsEmitter.JsEmitter_emitRun(emitter_, moduleName_, module_.functions_, packagePair_, ((packagePair_.group_ === "ff") && (packagePair_.name_ === "compiler")));
+const jsRunFile_ = ff_core_Path.Path_slash(jsPath_, (moduleName_ + ".run.mjs"));
+return ff_core_Path.Path_writeText(jsRunFile_, ff_core_List.List_join(ff_core_List.List_map(runJs_, ((_w1) => {
+return (_w1 + "\n")
+})), ""))
+})())
+} else return ff_core_Option.None()
 }))
 }))
 }
@@ -405,7 +415,7 @@ return ff_compiler_Dictionaries.Dictionaries_processModule(ff_compiler_Dictionar
 }
 
 export async function Compiler_emit$(self_, packagePair_, moduleName_, isMainModule_, $task) {
-(await ff_compiler_ModuleCache.ModuleCache_cacheEmittedModule$(self_.cache_, self_.packagePaths_, packagePair_, moduleName_, (async (path_, $task) => {
+(await ff_compiler_ModuleCache.ModuleCache_cacheEmittedModule$(self_.cache_, self_.packagePaths_, packagePair_, moduleName_, isMainModule_, (async (path_, $task) => {
 (await ff_compiler_Compiler.Compiler_measure$(self_, "Emit", packagePair_, moduleName_, (async ($task) => {
 const module_ = (await ff_compiler_Compiler.Compiler_infer$(self_, packagePair_, moduleName_, $task));
 const otherModules_ = (await ff_core_List.List_map$((await ff_compiler_Compiler.Compiler_imports$(self_, module_, $task)), (async (i_, $task) => {
@@ -414,17 +424,25 @@ const newModuleName_ = ff_core_String.String_dropLast(i_.file_, ".ff".length);
 return (await ff_compiler_Compiler.Compiler_infer$(self_, i_.packagePair_, newModuleName_, $task))
 }), $task));
 const allModules_ = [module_, ...otherModules_];
-const js_ = ff_compiler_JsEmitter.JsEmitter_emitModule(ff_compiler_JsEmitter.new_(allModules_, self_.emitTarget_, isMainModule_, (await ff_core_Option.Option_map$(self_.compilerModulePath_, (async (_w1, $task) => {
+const emitter_ = ff_compiler_JsEmitter.new_(allModules_, self_.emitTarget_, isMainModule_, (await ff_core_Option.Option_map$(self_.compilerModulePath_, (async (_w1, $task) => {
 return (await ff_core_Path.Path_url$(_w1, $task))
-}), $task)), packagePair_, moduleName_), packagePair_, module_);
+}), $task)), packagePair_, moduleName_);
+const js_ = ff_compiler_JsEmitter.JsEmitter_emitModule(emitter_, packagePair_, module_);
 const jsPath_ = (await ff_core_Path.Path_slash$((await ff_core_Path.Path_slash$(self_.jsOutputPath_, packagePair_.group_, $task)), packagePair_.name_, $task));
 const jsFile_ = (await ff_core_Path.Path_slash$(jsPath_, (moduleName_ + ".mjs"), $task));
 (await ff_core_Path.Path_createDirectory$(jsPath_, true, $task));
-return (await ff_core_Path.Path_writeText$(jsFile_, js_, $task))
+(await ff_core_Path.Path_writeText$(jsFile_, js_, $task));
+if(isMainModule_) {
+return ff_core_Option.Some((await (async function() {
+const runJs_ = ff_compiler_JsEmitter.JsEmitter_emitRun(emitter_, moduleName_, module_.functions_, packagePair_, ((packagePair_.group_ === "ff") && (packagePair_.name_ === "compiler")));
+const jsRunFile_ = (await ff_core_Path.Path_slash$(jsPath_, (moduleName_ + ".run.mjs"), $task));
+return (await ff_core_Path.Path_writeText$(jsRunFile_, ff_core_List.List_join(ff_core_List.List_map(runJs_, ((_w1) => {
+return (_w1 + "\n")
+})), ""), $task))
+})()))
+} else return ff_core_Option.None()
 }), $task))
 }), $task))
 }
 
 
-
-

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

@@ -415,5 +415,3 @@ if(ff_core_Equal.notEquals_(newDependencies_, [], ff_core_List.ff_core_Equal_Equ
 }
 
 
-
-

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

@@ -130,5 +130,3 @@ return (await body_($task))
 }
 
 
-
-

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

@@ -1052,5 +1052,3 @@ throw Object.assign(new Error(), {ffException: ff_core_Any.toAny_(ff_core_Serial
 }
 }
 };
-
-

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

@@ -1093,5 +1093,3 @@ throw Object.assign(new Error(), {ffException: ff_core_Any.toAny_(ff_core_Serial
 }
 }
 };
-
-