firefly-compiler 0.5.79 → 0.5.80

package/experimental/proxy/Tcp.ff

@@ -0,0 +1,162 @@
+import Tcp
+
+capability TcpServer(
+    system: NodeSystem
+    jsValue: JsValue
+    host: Option[String]
+    port: Option[Int]
+    path: Option[String]
+    backlog: Int
+    exclusive: Bool
+    ipv6Only: Bool
+    reusePort: Bool
+    readableAll: Bool
+    writeableAll: Bool
+)
+
+capability TcpSocket(system: NodeSystem, jsValue: JsValue)
+
+new(
+    system: NodeSystem
+    port: Int // TODO
+): TcpSocket {
+    let net = Js.import("node:net")
+    let jsValue = net->createConnection(Js->(
+        port = port
+    ))
+    TcpSocket(system, jsValue)    
+}
+
+newServer(
+    system: NodeSystem
+    host: Option[String] = None
+    port: Option[Int] = None
+    path: Option[String] = None
+    exclusive: Bool = False
+    allowHalfOpen: Bool = False 
+    highWaterMark: Int = 65536
+    keepAlive: Bool = False
+    noDelay: Bool = False
+    backlog: Int = 511
+    ipv6Only: Bool = False
+    reusePort: Bool = False
+    readableAll: Bool = False
+    writeableAll: Bool = False
+): TcpServer {
+    let net = Js.import("node:net")
+    let jsValue = net->createServer(Js->(
+        allowHalfOpen = allowHalfOpen
+        highWaterMark = highWaterMark
+        keepAlive = keepAlive
+        noDelay = noDelay
+    ))
+    TcpServer(system, jsValue, host, port, path, backlog, exclusive, ipv6Only, reusePort, readableAll, writeableAll)
+}
+
+extend self: TcpServer {
+    
+    listen(body: TcpSocket => Unit) {
+        Js.withSignal {signal =>
+            self.jsValue->listen(Js->(
+                host = Js.orUndefined(self.host)
+                port = Js.orUndefined(self.port)
+                path = Js.orUndefined(self.path)
+                backlog = self.backlog
+                exclusive = self.exclusive
+                ipv6Only = self.ipv6Only
+                reusePort = self.reusePort
+                readableAll = self.readableAll
+                writeableAll = self.writeableAll
+                signal = signal
+            ))
+            Js.awaitCancellablePromise {resolve, reject, cleanup => 
+                self.jsValue->on("connection", Js->{jsSocket =>
+                    jsSocket->on("error", Js->{jsError => 
+                        jsSocket->destroySoon()
+                        reject(jsError?)
+                    })
+                    try {
+                        body(TcpSocket(self.system, jsSocket))
+                    } tryFinally {
+                        jsSocket->destroySoon()
+                    } catchAny {error =>
+                        reject(error)
+                    }
+                })
+                self.jsValue->on("close", Js->{
+                    resolve(Unit)
+                })
+                self.jsValue->on("error", Js->{jsError => 
+                    reject(jsError?)
+                })
+            }
+        }
+    }
+    
+    close() {
+        Js.await(self.jsValue->close())
+    }
+    
+}
+
+extend self: TcpSocket {
+    
+    readStream(): Stream[Buffer] {
+        Path.internalReadStream({self.jsValue}, close = False)
+    }
+    
+    writeStream(stream: Stream[Buffer]) {
+        stream.each {self.writeBuffer(_)}
+    }
+
+    writeBuffer(buffer: Buffer): Unit {
+        if(!self.jsValue->write(Js->Uint8Array->(buffer!->buffer, buffer!->byteOffset, buffer!->byteLength))?) {
+            Js.withSignal {signal =>
+                Js.await(Js->Promise->(Js->{resolve, reject =>
+                    let jsDoReject = Js->{_ => reject->callValue1(signal->reason?)}
+                    signal->addEventListener("abort", jsDoReject)
+                    self.jsValue->once("drain", Js->{
+                        signal->removeEventListener("abort", jsDoReject)
+                        resolve.callValue0()
+                    })
+                }))
+            }
+        }
+    }
+    
+    writeText(text: String): Unit {
+        self.writeBuffer(text.toBuffer())
+    }
+
+    writeLine(text: String): Unit {
+        self.writeText(text + "\n")
+    }
+
+}
+
+nodeMain(system: NodeSystem) {
+    let targetSocket = Tcp.new(system, 8080)
+    Tcp.newServer(system, port = Some(8081)).listen {socket =>
+        system.writeLine("Connected!")
+        system.mainTask().all([
+            {
+                try {
+                    targetSocket.writeStream(socket.readStream())
+                } catchAny {error =>
+                    
+                }
+            }
+            {
+                try {
+                    socket.writeStream(targetSocket.readStream())
+                } catchAny {error =>
+                    
+                }
+            }
+        ])
+        system.writeLine("Disconnected!")
+    }
+    system.writeLine("Done!")
+}
+
+

package/experimental/random/Superdigit.ff

@@ -0,0 +1,18 @@
+nodeMain(system: NodeSystem) {
+    let lines = system.readStream().toString().lines()
+    lines.{
+        | [line, ""] {line.split(' ') | [digits, times]} => 
+            mutable result = digits.repeat(times.grabInt()).grabInt()
+            while {result >= 10} {
+                let newDigits = "" + result
+                result = 0
+                newDigits.each {digit =>
+                    result += digit.toString().grabInt()
+                }
+            }
+            system.writeLine(Show.show(result))
+        | _ => 
+            system.writeErrorLine("Unexpected input: " + Show.show(lines))
+    }
+}
+

package/experimental/terrain/Main.ff

@@ -0,0 +1,40 @@
+dependency ff:webserver:0.0.0
+import WebServer from ff:webserver
+import Terrain2
+
+browserMain(system: BrowserSystem): Unit {
+    let document = system.js()->document
+    let canvas = document->createElement("canvas")
+    canvas->width = "256"
+    canvas->height = "256"
+    canvas->style->scale = "3"
+    canvas->style->position = "absolute"
+    canvas->style->top = "calc(50% - 256px / 2)"
+    canvas->style->left = "calc(50% - 256px / 2)"
+    canvas->style->"image-rendering" = "pixelated"
+    document->body->appendChild(canvas)
+    document->body->parentElement->style->background = "#000000"
+    let context = canvas->getContext("2d")
+    Terrain2.generateAndDraw(system, context)
+}
+
+nodeMain(system: NodeSystem): Unit {
+    WebServer.new(system, "localhost", 8080).listen {request =>
+        if(request.readPath() == "/") {
+            request.writeHeader("Content-Type", "text/html; charset=UTF-8")
+            request.writeText("<!doctype html>")
+            request.writeText("<script type='module' src='/js/script/script/Main.run.mjs'></script>")
+        } elseIf {request.readPath().startsWith("/js/") && !request.readPath().contains("..")} {
+            request.writeHeader("Content-Type", "text/javascript; charset=UTF-8")
+            request.writeText(system.assets().readText(request.readPath()))
+        } else {
+            request.writeStatus("404 Not found")
+        }
+    }
+}
+
+buildMain(system: BuildSystem) {
+    let browserAssets = system.compileForBrowser(["Main.ff"])
+    let assets = AssetSystem.create().addAssets("/js", browserAssets)
+    system.setAssets(assets)
+}

package/experimental/terrain/Terrain.ff

@@ -0,0 +1,97 @@
+generateAndDraw(context: JsValue) {
+    let imageData = context->createImageData(width, height)
+    generate(imageData->data, 123, 1000)
+    render(imageData->data)
+    context->putImageData(imageData, 0, 0)
+}
+
+generate(data: JsValue, seed: Int, iterations: Int) {
+    initialize(data)
+    let directionsX = [-1, -1, -1,  1, 1, 1,  0, 0]
+    let directionsY = [-1,  0,  1, -1, 0, 1, -1, 1]
+    let random = Random.newFromInt(seed)
+    0.until(iterations).each {iteration =>
+        mutable i = 0
+        0.until(height).each {y =>
+            0.until(width).each {x =>
+                mutable bestDirection = random.nextInt(0, 8)
+                mutable bestDifference = 0
+                0.until(8).each {direction =>
+                    let myWater: Int = data.get(i + 2)?
+                    let myGround: Int = data.get(i + 1)?
+                    let myZ = myGround + myWater
+                    let theirX = (width + x + directionsX.grab(direction)) % width
+                    let theirY = (height + y + directionsY.grab(direction)) % height
+                    let theirI = 4 * (theirX + width * theirY)
+                    let theirWater: Int = data.get(theirI + 2)?
+                    let theirGround: Int = data.get(theirI + 1)?
+                    let theirZ = theirGround + theirWater
+                    if(myZ - theirZ > bestDifference) {
+                        bestDifference = myZ - theirZ
+                        bestDirection = direction
+                    }
+                }
+                let myWater: Int = data.get(i + 2)?
+                let myGround: Int = data.get(i + 1)?
+                let myZ = myGround + myWater
+                let theirX = (width + x + directionsX.grab(bestDirection)) % width
+                let theirY = (height + y + directionsY.grab(bestDirection)) % height
+                let theirI = 4 * (theirX + width * theirY)
+                let theirWater: Int = data.get(theirI + 2)?
+                let theirGround: Int = data.get(theirI + 1)?
+                let theirZ = theirGround + theirWater
+                if(myZ > theirZ) {
+                    let w = (myZ - theirZ).max(0).min(myWater).div(2)
+                    let g = (myGround - theirGround).div(4)
+                    data.set(i + 1, myGround - g)
+                    data.set(i + 2, myWater - w)
+                    data.set(theirI + 2, theirWater + w)
+                }
+                i += 4
+            }
+        }
+    }
+}
+
+initialize(data: JsValue) {
+    let random = Random.newFromInt(12345)
+    mutable i = 0
+    0.until(height).each {y =>
+        0.until(width).each {x =>
+            //data.set(i, random.nextInt(0, 5) * random.nextInt(0, 5) * random.nextInt(0, 5) * random.nextInt(0, 4))
+            i += 1
+            data.set(i, if(x < 100 || y < 100) {0} else {random.nextInt(200, 255)})
+            i += 1
+            data.set(i, if(x < 100 || y < 100) {0} else {255})
+            i += 1
+            data.set(i, 255)
+            i += 1
+        }
+    }
+}
+
+render(data: JsValue) {
+    mutable i = 0
+    0.until(height).each {y =>
+        mutable light = 0
+        0.until(width).each {x =>
+            let sea: Int = data.get(i + 0)?
+            let ground: Int = data.get(i + 1)?
+            let water: Int = data.get(i + 2)?
+            if(ground > light) {light = ground} else {light -= 2}
+            //data.set(i, if(water < 100) {100 - (water - 100) * 15} else {0})
+            data.set(i, 0)
+            i += 1
+            data.set(i, ground) // if(ground < waterLevel) {0} else {ground})
+            i += 1
+            data.set(i, 0)
+            i += 1
+            let l = if(ground >= light) {255} else {255 - (light - ground) * 10}
+            //data.set(i, l)
+            i += 1
+        }
+    }
+}
+
+width: Int = 256
+height: Int = 256

package/experimental/terrain/Terrain2.ff

@@ -0,0 +1,109 @@
+generateAndDraw(system: BrowserSystem, context: JsValue) {
+    let imageData = context->createImageData(width, height)
+    let renderData = context->createImageData(width, height)
+    initialize(imageData->data)
+    let random = Random.newFromInt(123)
+    0.until(10).each {_ =>
+        0.until(10).each {_ => 
+            generate(imageData->data, random)
+        }
+        render(renderData->data, imageData->data)
+        context->putImageData(imageData, 0, 0)
+        system.mainTask().sleep(Duration(0.0))
+    }
+}
+
+generate(data: JsValue, random: Random) {
+    let directionsX = [-1, -1, -1,  1, 1, 1,  0, 0]
+    let directionsY = [-1,  0,  1, -1, 0, 1, -1, 1]
+    mutable i = 0
+    0.until(height).each {y =>
+        0.until(width).each {x =>
+            mutable bestDirection = random.nextInt(0, 8)
+            mutable bestDelta = 0
+            0.until(8).each {direction =>
+                let myGround: Int = data.get(i + 1)?
+                let myWater: Int = data.get(i + 2)?
+                let myZ = myGround + myWater
+                let theirX = (width + x + directionsX.grab(direction)) % width
+                let theirY = (height + y + directionsY.grab(direction)) % height
+                let theirI = 4 * (theirX + width * theirY)
+                let theirGround: Int = data.get(theirI + 1)?
+                let theirWater: Int = data.get(theirI + 2)?
+                let theirZ = theirGround + theirWater
+                let delta = myZ - theirZ
+                if(delta > bestDelta) {
+                    bestDelta = delta
+                    bestDirection = direction
+                }
+                if(myGround > theirGround + 10) {
+                    data.set(i + 1, myGround - 1)
+                    data.set(theirI + 1, theirGround + 1)
+                }
+            }
+            let myGround: Int = data.get(i + 1)?
+            let myWater: Int = data.get(i + 2)?
+            let theirX = (width + x + directionsX.grab(bestDirection)) % width
+            let theirY = (height + y + directionsY.grab(bestDirection)) % height
+            let theirI = 4 * (theirX + width * theirY)
+            let theirGround: Int = data.get(theirI + 1)?
+            let theirWater: Int = data.get(theirI + 2)?
+            if(bestDelta != 0 && myWater > 0) {
+                if(bestDelta <= 2 && random.nextBool()) {
+                    data.set(i + 1, myGround - 1)
+                    data.set(theirI + 1, theirGround - 1)
+                }
+                data.set(i + 2, myWater - 1)
+                data.set(theirI + 2, theirWater + 1)
+            }
+            if(random.nextBool()) {
+                data.set(i + 2, data.get(i + 2)? + 1)
+            }
+            i += 4
+        }
+    }
+}
+
+initialize(data: JsValue) {
+    let random = Random.newFromInt(12345)
+    mutable i = 0
+    0.until(height).each {y =>
+        0.until(width).each {x =>
+            let cx = x - width.div(2)
+            let cy = y - height.div(2)
+            let m = 255 - (cx * cx + cy * cy).toFloat().sqrt().toInt()
+            data.set(i, 0)
+            i += 1
+            data.set(i, m + random.nextInt(0, 8))
+            i += 1
+            data.set(i, 0)
+            i += 1
+            data.set(i, 255)
+            i += 1
+        }
+    }
+}
+
+render(target: JsValue, data: JsValue) {
+    mutable i = 0
+    0.until(height).each {y =>
+        mutable light = 0
+        0.until(width).each {x =>
+            let ground: Int = data.get(i + 1)?
+            let water: Int = data.get(i + 2)?
+            if(ground > light) {light = ground} else {light -= 1}
+            target.set(i, ground + ground - 128)
+            i += 1
+            target.set(i, ground)
+            i += 1
+            target.set(i, if(water > 70) {water + 100} else {water})
+            i += 1
+            let l = if(ground >= light) {255} else {255 - (light - ground) * 5}
+            target.set(i, l)
+            i += 1
+        }
+    }
+}
+
+width: Int = 256
+height: Int = 256

package/fireflysite/Main.ff

@@ -18,7 +18,6 @@ nodeMain(system: NodeSystem): Unit {
     let handlers = WebRouteHandler(Array.new())
     Router.handlers(handlers)
     let cacheSalt = system.crypto().randomBuffer(16)
-    system.writeLine("Listening on " + host + ":" + port)
     WebServer.new(system, host, port).listen {request =>
         let path = request.readPath()
         let segments = path.split('/').filter {s => s != "" && s != "." && s != ".."}

package/fireflysite/assets/markdown/reference/statements-and-expressions.md

@@ -6,7 +6,7 @@ When `;` is the last token on a line, it can be omitted.
 
 A statement is either a [local function definition](functions-and-methods), a local variable definition, an assignment or an expression.
 
-Field assignments were covered in [user defined types](user-defined types).
+Field assignments were covered in [user defined types](user-defined-types).
 
 
 # Local variables

package/lsp/CompletionHandler.ff

@@ -861,12 +861,12 @@ toplevelCompletion(lspHook: LspHook): List[CompletionInfo] {
                 "import WebServer from ff:webserver"
                 ""
                 "browserMain(system: BrowserSystem): Unit {"
-                "    let message = system.httpClient().get(\"http://localhost:8080/hello\", []) {_.readText()}"
+                "    let message = system.httpClient().get(\"/hello\", []) {_.readText()}"
                 "    system.js()->alert(message)"
                 "}"
                 ""
                 "nodeMain(system: NodeSystem): Unit {"
-                "    WebServer.make(system, \"localhost\", 8080).listen {request =>"
+                "    WebServer.new(system, \"localhost\", 8080).listen {request =>"
                 "        if(request.readPath() == \"/\") {"
                 "            request.writeHeader(\"Content-Type\", \"text/html; charset=UTF-8\")"
                 "            request.writeText(\"<!doctype html>\")"

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

@@ -121,42 +121,28 @@ export function PackageFiles(root_, packageFile_, files_) {
 return {root_, packageFile_, files_};
 }
 
-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)
-};
-ff_core_Path.Path_createDirectory(tempPath_, false);
-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_());
+export function build_(system_, emitTarget_, mainModules_, resolvedDependencies_, compilerModulePath_, jsOutputPath_, printMeasurements_, moduleCache_) {
+ff_core_Path.Path_createDirectory(jsOutputPath_, true);
+const compiler_ = ff_compiler_Compiler.new_(emitTarget_, ff_core_NodeSystem.NodeSystem_mainTask(system_), compilerModulePath_, jsOutputPath_, 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 moduleKey_ = for_a[for_i];
 ff_compiler_Compiler.Compiler_emit(compiler_, moduleKey_, true)
 };
 if(printMeasurements_) {
-ff_compiler_Compiler.Compiler_printMeasurements(compiler_)
+ff_compiler_Compiler.Compiler_printMeasurementsPerPhase(compiler_)
 };
 ff_core_Map.Map_each(resolvedDependencies_.packagePaths_, ((packagePair_, packagePath_) => {
 {
 const if_o = ff_core_Map.Map_get(resolvedDependencies_.packages_, packagePair_, ff_compiler_Syntax.ff_core_Ordering_Order$ff_compiler_Syntax_PackagePair)
 if(if_o.Some) {
 const packageInfo_ = if_o.value_;
-ff_compiler_Builder.processNodeModules_(system_, jsPathFile_, packagePath_, packageInfo_);
+ff_compiler_Builder.processNodeModules_(system_, jsOutputPath_, packagePath_, packageInfo_);
 if(ff_core_Equal.notEquals_(emitTarget_, ff_compiler_JsEmitter.EmitBrowser(), ff_compiler_JsEmitter.ff_core_Equal_Equal$ff_compiler_JsEmitter_EmitTarget)) {
-ff_compiler_Builder.processIncludes_(jsPathFile_, packagePath_, packageInfo_)
+ff_compiler_Builder.processIncludes_(jsOutputPath_, packagePath_, packageInfo_)
 }
 }
 }
-}), ff_compiler_Syntax.ff_core_Ordering_Order$ff_compiler_Syntax_PackagePair);
-return true
-}));
-if(success_) {
-if(ff_core_Path.Path_exists(jsOutputPath_, false, false, false)) {
-ff_core_Path.Path_delete(jsOutputPath_, 0, 100)
-};
-ff_core_Path.Path_renameTo(jsPathFile_, jsOutputPath_)
-}
+}), ff_compiler_Syntax.ff_core_Ordering_Order$ff_compiler_Syntax_PackagePair)
 }
 
 export function processIncludes_(jsPathFile_, packagePath_, info_) {
@@ -164,9 +150,11 @@ for(let for_a = info_.includes_, for_i = 0, for_l = for_a.length; for_i < for_l;
 const include_ = for_a[for_i];
 const fromPath_ = ff_core_Path.Path_slash(ff_core_Path.Path_slash(ff_core_Path.Path_slash(packagePath_, ".firefly"), "include"), include_.path_);
 const toPath_ = ff_core_Path.Path_slash(ff_core_Path.Path_slash(jsPathFile_, ff_compiler_Syntax.PackagePair_groupName(info_.package_.packagePair_, "/")), include_.path_);
+if((!ff_core_Path.Path_exists(toPath_, false, false, false))) {
 ff_core_Path.Path_createSymlinkTo(toPath_, fromPath_, true)
 }
 }
+}
 
 export function processNodeModules_(system_, jsPathFile_, packagePath_, info_) {
 if(ff_core_List.List_any(info_.includes_, ((_w1) => {
@@ -177,7 +165,7 @@ const nodeModules_ = ff_core_Path.Path_slash(includePath_, "node_modules");
 const packageJson_ = ff_core_Path.Path_slash(includePath_, "package.json");
 if(((!ff_core_Path.Path_exists(nodeModules_, false, false, false)) && ff_core_Path.Path_exists(packageJson_, false, false, false))) {
 ff_core_NodeSystem.NodeSystem_writeErrorLine(system_, ("Running npm install --no-bin-links in " + ff_core_Path.Path_absolute(includePath_)));
-const result_ = ff_core_NodeSystem.NodeSystem_execute(system_, "npm", ["install", "--no-bin-links"], ff_core_Buffer.new_(0, false), ff_core_Option.Some(includePath_), ff_core_Option.None(), 16777216, 9, true);
+const result_ = ff_core_NodeSystem.NodeSystem_execute(system_, "npm", ["install", "--no-bin-links"], ff_core_Buffer.new_(0, false), ff_core_Option.Some(includePath_), ff_core_Option.None(), 16777216, 9, true, ff_core_Option.None());
 if((result_.exitCode_ !== 0)) {
 ff_core_NodeSystem.NodeSystem_writeErrorLine(system_, (("Running npm failed with exit code " + result_.exitCode_) + ":"));
 ff_core_NodeSystem.NodeSystem_writeErrorBuffer(system_, result_.standardOut_);
@@ -187,7 +175,7 @@ ff_core_NodeSystem.NodeSystem_writeErrorBuffer(system_, result_.standardError_)
 }
 }
 
-export function buildViaBuildSystem_(system_, fireflyPath_, mainFiles_, target_) {
+export function buildViaBuildSystem_(system_, fireflyPath_, mainFiles_, target_, moduleCache_ = ff_compiler_ModuleCache.new_(0), printMeasurements_ = false) {
 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_
@@ -203,7 +191,7 @@ ff_core_Core.panic_("buildViaBuildSystem is currently limited to browser target
 };
 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))
+}))(resolvedDependencies_), ff_core_Option.None(), ff_core_Path.Path_slash(ff_core_NodeSystem.NodeSystem_path(system_, ".firefly/output"), target_), printMeasurements_, moduleCache_)
 }
 
 export function check_(system_, fireflyPath_, path_, mustContain_, skipFiles_, virtualFiles_, cache_, dependencyLock_, newVersion_, lspHook_, infer_) {
@@ -387,42 +375,28 @@ const pkg_ = null;
 pkg_.exec([packageFile_.absolutePath_, "--out-path", outputPath_.absolutePath_, "--target", ff_core_List.List_join(targets_, ",")])
 }
 
-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))
-};
-(await ff_core_Path.Path_createDirectory$(tempPath_, false, $task));
-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));
+export async function build_$(system_, emitTarget_, mainModules_, resolvedDependencies_, compilerModulePath_, jsOutputPath_, printMeasurements_, moduleCache_, $task) {
+(await ff_core_Path.Path_createDirectory$(jsOutputPath_, true, $task));
+const compiler_ = (await ff_compiler_Compiler.new_$(emitTarget_, (await ff_core_NodeSystem.NodeSystem_mainTask$(system_, $task)), compilerModulePath_, jsOutputPath_, 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 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))
+(await ff_compiler_Compiler.Compiler_printMeasurementsPerPhase$(compiler_, $task))
 };
 (await ff_core_Map.Map_each$(resolvedDependencies_.packagePaths_, (async (packagePair_, packagePath_, $task) => {
 {
 const if_o = ff_core_Map.Map_get(resolvedDependencies_.packages_, packagePair_, ff_compiler_Syntax.ff_core_Ordering_Order$ff_compiler_Syntax_PackagePair)
 if(if_o.Some) {
 const packageInfo_ = if_o.value_;
-(await ff_compiler_Builder.processNodeModules_$(system_, jsPathFile_, packagePath_, packageInfo_, $task));
+(await ff_compiler_Builder.processNodeModules_$(system_, jsOutputPath_, packagePath_, packageInfo_, $task));
 if(ff_core_Equal.notEquals_(emitTarget_, ff_compiler_JsEmitter.EmitBrowser(), ff_compiler_JsEmitter.ff_core_Equal_Equal$ff_compiler_JsEmitter_EmitTarget)) {
-(await ff_compiler_Builder.processIncludes_$(jsPathFile_, packagePath_, packageInfo_, $task))
+(await ff_compiler_Builder.processIncludes_$(jsOutputPath_, packagePath_, packageInfo_, $task))
 }
 }
 }
-}), ff_compiler_Syntax.ff_core_Ordering_Order$ff_compiler_Syntax_PackagePair, $task));
-return true
-}), $task));
-if(success_) {
-if((await ff_core_Path.Path_exists$(jsOutputPath_, false, false, false, $task))) {
-(await ff_core_Path.Path_delete$(jsOutputPath_, 0, 100, $task))
-};
-(await ff_core_Path.Path_renameTo$(jsPathFile_, jsOutputPath_, $task))
-}
+}), ff_compiler_Syntax.ff_core_Ordering_Order$ff_compiler_Syntax_PackagePair, $task))
 }
 
 export async function processIncludes_$(jsPathFile_, packagePath_, info_, $task) {
@@ -430,9 +404,11 @@ for(let for_a = info_.includes_, for_i = 0, for_l = for_a.length; for_i < for_l;
 const include_ = for_a[for_i];
 const fromPath_ = (await ff_core_Path.Path_slash$((await ff_core_Path.Path_slash$((await ff_core_Path.Path_slash$(packagePath_, ".firefly", $task)), "include", $task)), include_.path_, $task));
 const toPath_ = (await ff_core_Path.Path_slash$((await ff_core_Path.Path_slash$(jsPathFile_, ff_compiler_Syntax.PackagePair_groupName(info_.package_.packagePair_, "/"), $task)), include_.path_, $task));
+if((!(await ff_core_Path.Path_exists$(toPath_, false, false, false, $task)))) {
 (await ff_core_Path.Path_createSymlinkTo$(toPath_, fromPath_, true, $task))
 }
 }
+}
 
 export async function processNodeModules_$(system_, jsPathFile_, packagePath_, info_, $task) {
 if(ff_core_List.List_any(info_.includes_, ((_w1) => {
@@ -443,7 +419,7 @@ const nodeModules_ = (await ff_core_Path.Path_slash$(includePath_, "node_modules
 const packageJson_ = (await ff_core_Path.Path_slash$(includePath_, "package.json", $task));
 if(((!(await ff_core_Path.Path_exists$(nodeModules_, false, false, false, $task))) && (await ff_core_Path.Path_exists$(packageJson_, false, false, false, $task)))) {
 (await ff_core_NodeSystem.NodeSystem_writeErrorLine$(system_, ("Running npm install --no-bin-links in " + (await ff_core_Path.Path_absolute$(includePath_, $task))), $task));
-const result_ = (await ff_core_NodeSystem.NodeSystem_execute$(system_, "npm", ["install", "--no-bin-links"], ff_core_Buffer.new_(0, false), ff_core_Option.Some(includePath_), ff_core_Option.None(), 16777216, 9, true, $task));
+const result_ = (await ff_core_NodeSystem.NodeSystem_execute$(system_, "npm", ["install", "--no-bin-links"], ff_core_Buffer.new_(0, false), ff_core_Option.Some(includePath_), ff_core_Option.None(), 16777216, 9, true, ff_core_Option.None(), $task));
 if((result_.exitCode_ !== 0)) {
 (await ff_core_NodeSystem.NodeSystem_writeErrorLine$(system_, (("Running npm failed with exit code " + result_.exitCode_) + ":"), $task));
 (await ff_core_NodeSystem.NodeSystem_writeErrorBuffer$(system_, result_.standardOut_, $task));
@@ -453,7 +429,7 @@ if((result_.exitCode_ !== 0)) {
 }
 }
 
-export async function buildViaBuildSystem_$(system_, fireflyPath_, mainFiles_, target_, $task) {
+export async function buildViaBuildSystem_$(system_, fireflyPath_, mainFiles_, target_, moduleCache_ = ff_compiler_ModuleCache.new_(0), printMeasurements_ = false, $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_
@@ -469,7 +445,7 @@ ff_core_Core.panic_("buildViaBuildSystem is currently limited to browser target
 };
 (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))
+}))(resolvedDependencies_), ff_core_Option.None(), (await ff_core_Path.Path_slash$((await ff_core_NodeSystem.NodeSystem_path$(system_, ".firefly/output", $task)), target_, $task)), printMeasurements_, moduleCache_, $task))
 }
 
 export async function check_$(system_, fireflyPath_, path_, mustContain_, skipFiles_, virtualFiles_, cache_, dependencyLock_, newVersion_, lspHook_, infer_, $task) {