firefly-compiler 0.5.46 → 0.5.48

package/.vscode/settings.json

@@ -1,5 +1,5 @@
 {
     "editor.suggest.showWords": false,
-    "firefly.trace.server": "messages",
+    "firefly.trace.server": "verbose",
     "editor.trimAutoWhitespace": false
 }

package/compiler/Builder.ff

@@ -136,7 +136,15 @@ check(
 
     packages.filter {!_.files.isEmpty()}.each {package => 
         let firstFile = package.files.grabFirst()
-        let resolvedDependencies = Dependencies.process(system.httpClient(), dependencyLock, firstFile)
+        try {
+            Some(Dependencies.process(system.httpClient(), dependencyLock, firstFile))
+        } tryCatch {| CompileError(_, _) @ c, error =>
+            errors.push(c)
+            None
+        } catch {| CompileErrors(compileErrors), error =>
+            errors.pushList(compileErrors)
+            None
+        }.each: resolvedDependencies => 
         let fixedPackagePaths = if(resolvedDependencies.packagePaths.contains(PackagePair("ff", "core"))) {
             resolvedDependencies.packagePaths
         } else {

package/compiler/Dependencies.ff

@@ -24,7 +24,7 @@ extend self: Dependencies {
     loadPackageInfo(
         packagePair: PackagePair
         path: Path
-    ): PackageInfo {
+    ): Option[PackageInfo] {
         let packageDirectory = if(path.extension() == ".ff") {path.parent().grab()} else {path}
         let sharedPackageFile = packageDirectory.slash(".firefly").slash("package.ff")
         let packageFile = if(sharedPackageFile.exists()) {
@@ -33,8 +33,8 @@ extend self: Dependencies {
             self.singleFilePackages = self.singleFilePackages.add(packagePair)
             path
         }
-        let code = packageFile.readText()
-        self.parsePackageFile(packagePair, packageFile.relativeTo(path), code)
+        try {packageFile.readText()}.toOption().map: code =>
+        self.parsePackageFile(packagePair, packageFile.absolute(), code)
     }
     
     parsePackageFile(
@@ -93,7 +93,7 @@ extend self: Dependencies {
                             Log.trace("Fetching " + location)
                             let buffer = httpClient.get(location, []) {response =>
                                 if(!response.ok()) {
-                                    panic("Could not download dependency: " + location)
+                                    throw(CompileError(dependency.at, "Could not download dependency: " + location))
                                 }
                                 response.readBuffer()
                             }
@@ -109,7 +109,7 @@ extend self: Dependencies {
                 }
                 dependencyPath
             } else {
-                panic("Loading packages by this protocol is not supported: " + location)
+                throw(CompileError(dependency.at, "Loading packages by this protocol is not supported: " + location))
             }
         } else {
             path.path(location)
@@ -126,7 +126,9 @@ extend self: Dependencies {
         let packageInfos = dependencies.map {dependency =>
             let dependencyPath = self.fetchDependency(path, httpClient, dependencyLock, dependency)
             self.packagePaths = self.packagePaths.add(dependency.packagePair, dependencyPath)
-            let packageInfo = self.loadPackageInfo(dependency.packagePair, dependencyPath)
+            let packageInfo = self.loadPackageInfo(dependency.packagePair, dependencyPath).else {
+                throw(CompileError(dependency.at, "Dependency not found: " + dependencyPath.absolute()))
+            }
             checkPackagePairs(dependency.packagePair, packageInfo.package.packagePair)
             packageInfo
         }
@@ -141,7 +143,9 @@ extend self: Dependencies {
 process(fetch: HttpClient, dependencyLock: DependencyLock, path: Path): ResolvedDependencies {
     let workspace = Workspace.loadWorkspace(path)
     let self = Dependencies(workspace, [].toMap(), [].toMap(), [].toSet())
-    let packageInfo = self.loadPackageInfo(PackagePair("script", "script"), path)
+    let packageInfo = self.loadPackageInfo(PackagePair("script", "script"), path).else {
+        panic("Not a main file: " + path.absolute())
+    }
     let newDependencies = self.processPackageInfo(packageInfo)
     self.processDependencies(path, fetch, dependencyLock, newDependencies)
     let packagePaths = self.packagePaths.add(packageInfo.package.packagePair, findScriptPackageLocation(path))

package/compiler/JsEmitter.ff

@@ -279,7 +279,7 @@ extend self: JsEmitter {
         }
     }
 
-    emitTerm(term: Term, async: Bool): String {term.{
+    emitTerm(term: Term, async: Bool, ignored: Bool = False): String {term.{
         | EString(at, value) {value.startsWith("\"\"\"")} =>
             "`" + value.dropFirst(3).dropLast(3).replace("`", "\\`") + "`" // TODO: Fix escaping
         | EString(at, value) => value
@@ -347,6 +347,8 @@ extend self: JsEmitter {
             let c = if(await) {", $task"} else {""}
             let call = "(" + self.emitTerm(function, async) + ")(" + self.emitTerm(value, async) + c + ")"
             if(await) {"(await " + call + ")"} else {call}
+        | _ {self.emitAssignment(term, async) | Some(code)} =>
+            if(ignored) {code} else {"(" + code + ", void 0)"}
         | ECall(at, StaticCall(name, _, _), _, _, arguments, dictionaries) {
             self.emitSpecialCall(term, async, name, arguments.map {_.value}, dictionaries) | Some(code)
         } =>
@@ -379,14 +381,14 @@ extend self: JsEmitter {
                     let call = functionCode + "(" + [...emittedArguments, ...ds, ...controller].join(", ") + ")"
                     if(await) {"(await " + call + ")"} else {call}
                 | [Pair(EVariant(_, "ff:core/Bool.True", _, _), elseBody), ...list] =>
-                    "(" + list.foldLeft(self.emitComma(elseBody, async)) {| otherwise, Pair(condition, body) =>
-                        self.emitComma(condition, async) +
-                        "\n? " + self.emitComma(body, async) + "\n: " + otherwise
+                    "(" + list.foldLeft(self.emitTerm(elseBody, async)) {| otherwise, Pair(condition, body) =>
+                        self.emitTerm(condition, async) +
+                        "\n? " + self.emitTerm(body, async) + "\n: " + otherwise
                     } + ")"
                 | list =>
                     "(" + list.foldLeft("ff_core_Option.None()") {| otherwise, Pair(condition, body) =>
-                        self.emitComma(condition, async) +
-                        "\n? ff_core_Option.Some(" + self.emitComma(body, async) + ")\n: " + otherwise
+                        self.emitTerm(condition, async) +
+                        "\n? ff_core_Option.Some(" + self.emitTerm(body, async) + ")\n: " + otherwise
                     } + ")"
             }
         | ECall(at, DynamicCall(function, _), effect, typeArguments, arguments, dictionaries) =>
@@ -405,6 +407,24 @@ extend self: JsEmitter {
         | EWildcard(at, index) =>
             if(index == 0) {fail(at, "Unbound wildcard")}
             "_w" + index
+        | ESequential(_, ESequential(_, ESequential(_, before1, before2), before3), after) {
+            safeCommable(before1) && safeCommable(before2) && safeCommable(before3) && safeCommable(after)
+        } =>
+            "(" + self.emitTerm(before1, async, ignored = True) + ", " + 
+            self.emitTerm(before2, async, ignored = True) + ", " + 
+            self.emitTerm(before3, async, ignored = True) + ", " + 
+            self.emitTerm(after, async, ignored) + ")"
+        | ESequential(_, ESequential(_, before1, before2), after) {
+            safeCommable(before1) && safeCommable(before2) && safeCommable(after)
+        } =>
+            "(" + self.emitTerm(before1, async, ignored = True) + ", " + 
+            self.emitTerm(before2, async, ignored = True) + ", " + 
+            self.emitTerm(after, async, ignored) + ")"
+        | ESequential(_, before, after) {
+            safeCommable(before) && safeCommable(after)
+        } =>
+            "(" + self.emitTerm(before, async, ignored = True) + ", " + 
+            self.emitTerm(after, async, ignored) + ")"
         | _ {async} =>
             "(await (async function() {\n" + self.emitStatements(term, True, False, async) + "\n})())"
         | _ =>
@@ -450,11 +470,6 @@ extend self: JsEmitter {
             | ESequential(at, before, after) =>
                 self.emitStatements(before, False, False, async) + ";\n" + 
                 self.emitStatements(after, last, break, async)
-            | EAssign(at, operator, name, value) =>
-                escapeKeyword(name) + " " + operator + "= " + self.emitTerm(value, async)
-            | EAssignField(at, operator, record, field, value) =>
-                self.emitTerm(record, async) + "." + escapeKeyword(field) + " " + operator + "= " +
-                self.emitTerm(value, async)
             | ECall(at, StaticCall(name, True, instanceCall), effect, _, arguments, _) =>
                 if(instanceCall) {throw(CompileError(at, "Not yet implemented: Tail calls on trait methods."))}
                 self.tailCallUsed = True
@@ -478,15 +493,17 @@ extend self: JsEmitter {
                     self.emitCase(["_1"], c, [], [], True, last, break, lastCase, async)
                 }.join("\n") +
                 "\n}" + if(!last && !break) {" while(false)"}.else {""}
+            | _ {self.emitAssignment(term, async) | Some(code)} =>
+                code
             | _ =>
                 detectIfElse(term).{
                     | [] =>
                         if(break) {
-                            "if(!" + self.emitComma(term, async) + ") break"
+                            "if(!" + self.emitTerm(term, async) + ") break"
                         } elseIf {last} {
                             "return " + self.emitTerm(term, async)
                         } else {
-                            self.emitTerm(term, async)
+                            self.emitTerm(term, async, ignored = True)
                         }
                     | [Pair(EVariant(_, "ff:core/Bool.True", _, _), elseBody), ...list] =>
                         let initial = "{\n" + self.emitStatements(elseBody, last, break, async) + "\n}"
@@ -508,6 +525,49 @@ extend self: JsEmitter {
         }
     }
     
+    emitAssignment(
+        term: Term
+        async: Bool
+    ): Option[String] {
+        | ECall(at, StaticCall(name, _, _), _, _, arguments, dictionaries), _ =>
+            name.{
+                | "ff:core/JsValue.JsValue_set" {arguments.map {_.value} | [e1, e2, e3]} =>
+                    Some(self.emitTerm(e1, async) + self.emitField(e2, async) + " = " + self.emitTerm(e3, async))
+                | "ff:core/JsValue.JsValue_increment" {arguments.map {_.value} | [e1, e2, e3]} =>
+                    Some(self.emitTerm(e1, async) + self.emitField(e2, async) + " += " + self.emitTerm(e3, async))
+                | "ff:core/JsValue.JsValue_decrement" {arguments.map {_.value} | [e1, e2, e3]} =>
+                    Some(self.emitTerm(e1, async) + self.emitField(e2, async) + " -= " + self.emitTerm(e3, async))
+                | "ff:core/JsSystem.JsSystem_set" {arguments.map {_.value} | [e1, EString(_, q), e3]} {
+                    noSideEffects(e1)} {safeBare(q) | Some(s)
+                } =>
+                    Some(s + " = " + self.emitTerm(e3, async))
+                | "ff:core/JsSystem.JsSystem_increment" {arguments.map {_.value} | [e1, EString(_, q), e3]} {
+                    noSideEffects(e1)} {safeBare(q) | Some(s)
+                } =>
+                    Some(s + " += " + self.emitTerm(e3, async))
+                | "ff:core/JsSystem.JsSystem_decrement" {arguments.map {_.value} | [e1, EString(_, q), e3]} {
+                    noSideEffects(e1)} {safeBare(q) | Some(s)
+                } =>
+                    Some(s + " -= " + self.emitTerm(e3, async))
+                | "ff:core/Js.set" {arguments.map {_.value} | [EString(_, q), e2]} {safeBare(q) | Some(s)} =>
+                    Some(s + " = " + self.emitTerm(e2, async))
+                | "ff:core/Js.increment" {arguments.map {_.value} | [EString(_, q), e2]} {safeBare(q) | Some(s)} =>
+                    Some(s + " += " + self.emitTerm(e2, async))
+                | "ff:core/Js.decrement" {arguments.map {_.value} | [EString(_, q), e2]} {safeBare(q) | Some(s)} =>
+                    Some(s + " -= " + self.emitTerm(e2, async))
+                | _ => None
+            }
+        | EAssign(at, operator, name, value), _ =>
+            Some(escapeKeyword(name) + " " + operator + "= " + self.emitTerm(value, async))
+        | EAssignField(at, operator, record, field, value), _ =>
+            Some(
+                self.emitTerm(record, async) + "." + escapeKeyword(field) + " " + operator + "= " +
+                self.emitTerm(value, async)
+            )
+        | _, _ =>
+            None
+    }
+    
     emitSpecialCall(
         term: Term
         async: Bool
@@ -794,7 +854,7 @@ extend self: JsEmitter {
         name.{
             | "ff:core/Core.while" {arguments | [condition, body]} =>
                 Some(
-                    "while(" + self.emitComma(invokeImmediately(condition), async) + ") {\n" +
+                    "while(" + self.emitTerm(invokeImmediately(condition), async) + ") {\n" +
                     self.emitStatements(invokeImmediately(body), False, False, async) + "\n}"
                 )
             | "ff:core/Core.doWhile" {arguments | [doWhileBody]} {
@@ -906,7 +966,7 @@ extend self: JsEmitter {
                 Some(self.emitTerm(array, async) + ".array.push(" + self.emitTerm(value, async) + ")")
             | "ff:core/Core.if" {arguments | [condition, body]} =>
                 Some(
-                    "if(" + self.emitComma(condition, async) + ") {\n" +
+                    "if(" + self.emitTerm(condition, async) + ") {\n" +
                     if(last) {
                         "return ff_core_Option.Some(" + self.emitTerm(invokeImmediately(body), async) +
                         ")\n} else return ff_core_Option.None()"
@@ -928,24 +988,6 @@ extend self: JsEmitter {
                 Some(if(async) {"ff_core_Task.Task_throwIfAborted($task)"} else {""})
             | "ff:core/Js.throw" {term | ECall c} {c.arguments | [argument]} =>
                 Some("throw " + self.emitTerm(argument.value, async))
-            | "ff:core/JsValue.JsValue_set" {arguments | [e1, e2, e3]} =>
-                Some(self.emitTerm(e1, async) + self.emitField(e2, async) + " = " + self.emitTerm(e3, async))
-            | "ff:core/JsValue.JsValue_increment" {arguments | [e1, e2, e3]} =>
-                Some(self.emitTerm(e1, async) + self.emitField(e2, async) + " += " + self.emitTerm(e3, async))
-            | "ff:core/JsValue.JsValue_decrement" {arguments | [e1, e2, e3]} =>
-                Some(self.emitTerm(e1, async) + self.emitField(e2, async) + " -= " + self.emitTerm(e3, async))
-            | "ff:core/JsSystem.JsSystem_set" {arguments | [e1, EString(_, q), e3]} {noSideEffects(e1)} {safeBare(q) | Some(s)} =>
-                Some(s + " = " + self.emitTerm(e3, async))
-            | "ff:core/JsSystem.JsSystem_increment" {arguments | [e1, EString(_, q), e3]} {noSideEffects(e1)} {safeBare(q) | Some(s)} =>
-                Some(s + " += " + self.emitTerm(e3, async))
-            | "ff:core/JsSystem.JsSystem_decrement" {arguments | [e1, EString(_, q), e3]} {noSideEffects(e1)} {safeBare(q) | Some(s)} =>
-                Some(s + " -= " + self.emitTerm(e3, async))
-            | "ff:core/Js.set" {arguments | [EString(_, q), e2]} {safeBare(q) | Some(s)} =>
-                Some(s + " = " + self.emitTerm(e2, async))
-            | "ff:core/Js.increment" {arguments | [EString(_, q), e2]} {safeBare(q) | Some(s)} =>
-                Some(s + " += " + self.emitTerm(e2, async))
-            | "ff:core/Js.decrement" {arguments | [EString(_, q), e2]} {safeBare(q) | Some(s)} =>
-                Some(s + " -= " + self.emitTerm(e2, async))
             | _ =>
                 None
         }
@@ -1280,31 +1322,6 @@ extend self: JsEmitter {
         }
     }
     
-    emitComma(term: Term, async: Bool): String {
-        term.{
-            | ESequential(_, ESequential(_, ESequential(_, before1, before2), before3), after) {
-                safeCommable(before1) && safeCommable(before2) && safeCommable(before3) && safeCommable(after)
-            } =>
-                "(" + self.emitStatements(before1, False, False, async) + ", " + 
-                self.emitStatements(before2, False, False, async) + ", " + 
-                self.emitStatements(before3, False, False, async) + ", " + 
-                self.emitTerm(after, async) + ")"
-            | ESequential(_, ESequential(_, before1, before2), after) {
-                safeCommable(before1) && safeCommable(before2) && safeCommable(after)
-            } =>
-                "(" + self.emitStatements(before1, False, False, async) + ", " + 
-                self.emitStatements(before2, False, False, async) + ", " + 
-                self.emitTerm(after, async) + ")"
-            | ESequential(_, before, after) {
-                safeCommable(before) && safeCommable(after)
-            } =>
-                "(" + self.emitStatements(before, False, False, async) + ", " + 
-                self.emitTerm(after, async) + ")"
-            | _ =>
-                self.emitTerm(term, async)
-        }
-    }
-
 }
 
 data ProcessedVariantCase(

package/core/Buffer.ff

@@ -193,7 +193,7 @@ fromHex(hex: String): Buffer {
 
 fromBase64(base64: String): Buffer {
     let binaryString = Js->atob(base64)
-    let bytes = Js->Uint8Array->from(binaryString, Js->{char => char->CharCodeAt(0)})
+    let bytes = Js->Uint8Array->from(binaryString, Js->{char => char->charCodeAt(0)})
     Js->DataView->(bytes->buffer)?
 }
 

package/core/Map.ff

@@ -29,6 +29,14 @@ extend self[K: Order, V]: Map[K, V] {
     get(key: K): Option[V] {
         self.redBlack.get(key)
     }
+    
+    lastBefore(key: K): Option[Pair[K, V]] {
+        self.redBlack.lastBefore(key)
+    }
+    
+    firstAfter(key: K): Option[Pair[K, V]] {
+        self.redBlack.firstAfter(key)
+    }
 
     remove(key: K): Map[K, V] {
         Map(RbMap.delete(key, self.redBlack))

package/core/RbMap.ff

@@ -123,6 +123,22 @@ extend self[K: Order, V]: RB[K, V] {
             }
         }
     }
+    
+    lastBefore(key: K): Option[Pair[K, V]] {
+        self.{
+            | E => None
+            | T(_, l, k, v, r) {k >= key} => l.lastBefore(key)
+            | T(_, l, k, v, r) => r.lastBefore(key).orElse {Some(Pair(k, v))}
+        }
+    }
+    
+    firstAfter(key: K): Option[Pair[K, V]] {
+        self.{
+            | E => None
+            | T(_, l, k, v, r) {k <= key} => r.firstAfter(key)
+            | T(_, l, k, v, r) => l.firstAfter(key).orElse {Some(Pair(k, v))}
+        }
+    }
 
     size(): Int {
         self.{

package/core/Set.ff

@@ -17,6 +17,8 @@ extend self[T: Order]: Set[T] {
     remove(value: T): Set[T] {Set(self.map.remove(value))}
     removeAll(that: Set[T]): Set[T] {Set(self.map.removeAll(that.map))}
     contains(value: T): Bool {self.map.contains(value)}
+    lastBefore(key: T): Option[T] {self.map.lastBefore(key).map {_.first}}
+    firstAfter(key: T): Option[T] {self.map.firstAfter(key).map {_.first}}
     size(): Int {self.map.size()}
     toList(): List[T] {self.map.toList().map {_.first}}
     toStream(cycle: Bool = False): Stream[T] {self.map.toStream(cycle).map {_.first }}
@@ -41,4 +43,4 @@ instance Set[A: Show: Order]: Show {
     show(value: Set[A]): String {
         Show.show(value.toList()) + ".toSet()"
     }
-}
+}

package/experimental/IfBug.ff

@@ -0,0 +1,8 @@
+nodeMain(system: NodeSystem) {
+    let r = if(42 == 1) {
+        if(42 == 11) {
+            Log.debug("11")
+        }
+        Log.debug("1")
+    }
+}

package/experimental/site/.firefly/package.ff

@@ -0,0 +1,3 @@
+package ff:site:0.0.0
+dependency ff:webserver:0.0.0
+dependency ff:lux:0.0.0

package/experimental/site/ChatRoute.ff

@@ -0,0 +1,26 @@
+import Lux from ff:lux
+import WebServer from ff:webserver
+import RouteTools
+
+data Chat(room: String)
+
+pageRoute = PageRoute("ChatRoute", "/chat/{roomId}")
+
+handle(system: NodeSystem, request: WebRequest[WebResponse], context: Context) {
+    let pageData = Chat("42")
+    let title = "Chat"
+    RouteTools.renderAndServe(system, pageRoute, pageData, title, request, {render(_, pageData)})
+}
+
+browserMain(system: BrowserSystem) {
+    RouteTools.renderToMain(system, {render(_, _)})
+}
+
+render(lux: Lux, chat: Chat) {
+    lux.add("div") {
+        lux.add("h1") {
+            lux.text("Hello")
+        }
+    }
+}
+

package/experimental/site/Main.ff

@@ -0,0 +1,40 @@
+import WebServer from ff:webserver
+import RouteTools
+import Routes
+
+nodeMain(system: NodeSystem): Unit {
+    let host = system.arguments().grab(0)
+    let port = system.arguments().grab(1).grabInt()
+    let handlers = RouteTools.checkRoutesAndHandlers(Routes.routes, Routes.handlers())
+    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 != ".."}
+        segments.{
+            | ["js", ...] => 
+                let asset = segments.map {"/" + _}.join()
+                request.writeHeader("Content-Type", "text/javascript; charset=UTF-8")
+                request.writeStream(system.assets().readStream(asset))
+            | _ => 
+                // Very sketchy routing
+                let routeOption = Routes.routes.find {route =>
+                    let routeSegments = route.pattern.split('/').filter {s => s != "" && s != "." && s != ".."}
+                    if(segments.size() != routeSegments.size()) {False} else:
+                    segments.zip(routeSegments).all {| Pair(s, r) => s == r || r.startsWith("{")}
+                }
+                routeOption.or {request.writeStatus("404 Not Found")}: route =>
+                let context = Context()
+                let handle = handlers.grab(route.pattern)
+                handle(system, request, context)
+        }
+    }    
+}
+
+buildMain(system: BuildSystem) {
+    mutable assets = AssetSystem.create()
+    Routes.routes.each {route =>
+        let browser = system.compileForBrowser(route.page + ".ff") // .bundle()
+        assets = assets.addAssets("/js/", browser.assets())
+    }
+    system.setAssets(assets)
+}

package/experimental/site/RouteTools.ff

@@ -0,0 +1,70 @@
+import WebServer from ff:webserver
+import Lux from ff:lux
+
+data PageRoute(page: String, pattern: String)
+capability PageHandler(pattern: String, handle: (NodeSystem, WebRequest[WebResponse], Context) => Unit)
+
+data Context()
+
+serveHtml(
+    pageRoute: PageRoute
+    title: String
+    pageData: Buffer
+    contentHtml: String
+    styleTags: String
+    request: WebRequest[WebResponse]
+): Unit {
+    request.writeHeader("Content-Type", "text/html; charset=UTF-8")
+    request.writeText("<!doctype html>")
+    request.writeText("<html lang='en' style='background-color: #ffffff; color: #333333; width: 100%; height: 100%; color-scheme: light;'>")
+    request.writeText("<head>")
+    request.writeText("<title>" + title + "</title>")
+    request.writeText("<meta name='viewport' content='width=device-width, initial-scale=1.0'>")
+    request.writeText("<meta name='theme-color' content='#ecc45e'>")
+    request.writeText("<script type='module' src='" + "/js/ff/site/" + pageRoute.page + ".mjs" + "'></script>")
+    request.writeText("<script type='text/plain' id='data'>" + pageData.toBase64() + "</script>")
+    request.writeText(styleTags)
+    request.writeText("</head>")
+    request.writeText("<body style='margin: 0; padding: 0; width: 100%; height: 100%; touch-action: manipulation;'>")
+    request.writeText("<div id='main'>" + contentHtml + "</div>")
+    request.writeText("</body>")
+    request.writeText("</html>")
+}
+
+renderAndServe[T: Serializable](
+    system: NodeSystem
+    pageRoute: PageRoute
+    pageData: T
+    title: String
+    request: WebRequest[WebResponse]
+    render: Lux => Unit
+) {
+    let serialized = Serializable.serialize(pageData)
+    let htmlAndCss = Lux.renderToString(system, render)
+    serveHtml(pageRoute, title, serialized, htmlAndCss.first, htmlAndCss.second, request)
+}
+
+renderToMain[T: Serializable](system: BrowserSystem, render: (Lux, T) => Unit) {
+    let base64 = system.js()->document->getElementById("data")->textContent.grabString()
+    let chat = Serializable.deserialize(Buffer.fromBase64(base64))
+    Lux.renderById(system, "main") {lux =>
+        render(lux, chat)
+    }
+}
+
+checkRoutesAndHandlers(
+    routes: List[PageRoute]
+    handlers: List[PageHandler]
+): Map[String, (NodeSystem, WebRequest[WebResponse], Context) => Unit] {
+    let handlerMap = handlers.map {h => Pair(h.pattern, h.handle)}.toMap()
+    routes.each {r => 
+        if(!handlerMap.contains(r.pattern)) {
+            panic("Missing handler for " + r.pattern)
+        }
+    }
+    let missingPatterns = handlerMap.keys().removeAll(routes.map {_.pattern}.toSet())
+    missingPatterns.each {p =>
+        panic("Missing route for " + p)
+    }
+    handlerMap
+}

package/experimental/site/Routes.ff

@@ -0,0 +1,13 @@
+import WebServer from ff:webserver
+import RouteTools
+import ChatRoute
+
+routes: List[PageRoute] = [
+    ChatRoute.pageRoute
+]
+
+handlers(): List[PageHandler] {
+    [
+        PageHandler(ChatRoute.pageRoute.pattern, {ChatRoute.handle(_, _, _)})
+    ]
+}

package/experimental/site2/.firefly/package.ff

@@ -0,0 +1,3 @@
+package ff:site2:0.0.0
+dependency ff:webserver:0.0.0
+dependency ff:lux:0.0.0

package/experimental/site2/ChatRoomRoute.ff

@@ -0,0 +1,27 @@
+import Lux from ff:lux
+import WebServer from ff:webserver
+import Router
+import Html
+
+routeModule = SourceLocation.here().module()
+
+data Chat(room: String)
+
+handle(request: WebRequest[WebResponse], context: RouteContext, roomId: Int) {
+    let pageData = Chat("42")
+    let title = "Chat"
+    Html.renderAndServe(context.system, routeModule, pageData, title, request, {render(_, pageData)})
+}
+
+browserMain(system: BrowserSystem) {
+    Html.renderToMain(system, {render(_, _)})
+}
+
+render(lux: Lux, chat: Chat) {
+    lux.add("div") {
+        lux.add("h1") {
+            lux.text("Hello")
+        }
+    }
+}
+

package/experimental/site2/Html.ff

@@ -0,0 +1,49 @@
+import WebServer from ff:webserver
+import WebRoute from ff:webserver
+import Lux from ff:lux
+
+serveHtml(
+    moduleName: String
+    title: String
+    pageData: Buffer
+    contentHtml: String
+    styleTags: String
+    request: WebRequest[WebResponse]
+): Unit {
+    request.writeHeader("Content-Type", "text/html; charset=UTF-8")
+    request.writeText("<!doctype html>")
+    request.writeText("<html lang='en' style='background-color: #ffffff; color: #333333; width: 100%; height: 100%; color-scheme: light;'>")
+    request.writeText("<head>")
+    request.writeText("<title>" + title + "</title>")
+    request.writeText("<meta name='viewport' content='width=device-width, initial-scale=1.0'>")
+    request.writeText("<meta name='theme-color' content='#ecc45e'>")
+    request.writeText("<script type='module' src='" + "/js/ff/site2/" + moduleName + ".mjs" + "'></script>")
+    request.writeText("<script type='text/plain' id='data'>" + pageData.toBase64() + "</script>")
+    request.writeText(styleTags)
+    request.writeText("</head>")
+    request.writeText("<body style='margin: 0; padding: 0; width: 100%; height: 100%; touch-action: manipulation;'>")
+    request.writeText("<div id='main'>" + contentHtml + "</div>")
+    request.writeText("</body>")
+    request.writeText("</html>")
+}
+
+renderAndServe[T: Serializable](
+    system: NodeSystem
+    moduleName: String
+    pageData: T
+    title: String
+    request: WebRequest[WebResponse]
+    render: Lux => Unit
+) {
+    let serialized = Serializable.serialize(pageData)
+    let htmlAndCss = Lux.renderToString(system, render)
+    serveHtml(moduleName, title, serialized, htmlAndCss.first, htmlAndCss.second, request)
+}
+
+renderToMain[T: Serializable](system: BrowserSystem, render: (Lux, T) => Unit) {
+    let base64 = system.js()->document->getElementById("data")->textContent.grabString()
+    let chat = Serializable.deserialize(Buffer.fromBase64(base64))
+    Lux.renderById(system, "main") {lux =>
+        render(lux, chat)
+    }
+}

package/experimental/site2/Main.ff

@@ -0,0 +1,37 @@
+import WebServer from ff:webserver
+import WebRoute from ff:webserver
+import Html
+import Router
+
+nodeMain(system: NodeSystem): Unit {
+    let host = system.arguments().grab(0)
+    let port = system.arguments().grab(1).grabInt()
+    let context = RouteContext(system)
+    let handlers = WebRouteHandler(Array.new())
+    Router.handlers(handlers)
+    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 != ".."}
+        segments.{
+            | ["js", ...] => 
+                let asset = segments.map {"/" + _}.join()
+                request.writeHeader("Content-Type", "text/javascript; charset=UTF-8")
+                request.writeStream(system.assets().readStream(asset))
+            | _ =>
+                if(!handlers.handle(request, context)) {
+                    request.writeStatus("404 Not Found")
+                }
+                Unit
+        }
+    }    
+}
+
+buildMain(system: BuildSystem) {
+    mutable assets = AssetSystem.create()
+    Router.modulesWithBrowserMain.each {moduleName =>
+        let browser = system.compileForBrowser(moduleName + ".ff") // .bundle()
+        assets = assets.addAssets("/js/", browser.assets())
+    }
+    system.setAssets(assets)
+}