firefly-compiler 0.5.35 → 0.5.37

package/output/js/ff/core/BuildSystem.mjs

@@ -1,5 +1,7 @@
 import * as import$0 from 'esbuild';
 
+import * as import$1 from 'path';
+
 import * as ff_core_Any from "../../ff/core/Any.mjs"
 
 import * as ff_core_Array from "../../ff/core/Array.mjs"
@@ -42,6 +44,8 @@ import * as ff_core_Int from "../../ff/core/Int.mjs"
 
 import * as ff_core_IntMap from "../../ff/core/IntMap.mjs"
 
+import * as ff_core_Js from "../../ff/core/Js.mjs"
+
 import * as ff_core_JsSystem from "../../ff/core/JsSystem.mjs"
 
 import * as ff_core_JsValue from "../../ff/core/JsValue.mjs"
@@ -68,6 +72,8 @@ import * as ff_core_Pair from "../../ff/core/Pair.mjs"
 
 import * as ff_core_Path from "../../ff/core/Path.mjs"
 
+import * as ff_core_Queue from "../../ff/core/Queue.mjs"
+
 import * as ff_core_Random from "../../ff/core/Random.mjs"
 
 import * as ff_core_Serializable from "../../ff/core/Serializable.mjs"
@@ -90,8 +96,6 @@ import * as ff_core_Try from "../../ff/core/Try.mjs"
 
 import * as ff_core_Unit from "../../ff/core/Unit.mjs"
 
-import * as ff_core_UnsafeJs from "../../ff/core/UnsafeJs.mjs"
-
 // type BuildSystem
 
 
@@ -108,11 +112,13 @@ return {assetSystem_};
 
 
 export function internalCallEsBuild_(self_, mainJsFile_, outputPath_, minify_, sourceMap_) {
-throw new Error('Function internalCallEsBuild is missing on this target in sync context.');
+const esbuild_ = import$0;
+esbuild_.build({stdin: {contents: (("import {$run$} from './" + mainJsFile_) + "';"), resolveDir: "."}, bundle: true, minify: minify_, sourcemap: sourceMap_, platform: "browser", target: "es2017", external: ["../../../node_modules/*"], outfile: outputPath_})
 }
 
 export function internalNodeCallEsBuild_(self_, mainJsFile_, outputPath_, minify_) {
-throw new Error('Function internalNodeCallEsBuild is missing on this target in sync context.');
+const esbuild_ = import$0;
+esbuild_.build({entryPoints: [mainJsFile_], bundle: true, minify: minify_, sourcemap: true, platform: "node", target: "es2017", external: ["../../../node_modules/*"], outfile: outputPath_})
 }
 
 export function internalListDirectory_(path_) {
@@ -133,47 +139,26 @@ return ff_core_Path.Path_readStream(file_)
 }
 
 export function internalPath_(buildSystem_, absoluteOrRelative_) {
-throw new Error('Function internalPath is missing on this target in sync context.');
+const nodePath_ = import$1;
+return ff_core_Path.Path(nodePath_.resolve(absoluteOrRelative_))
 }
 
 export function internalCompile_(buildSystem_, mainFile_, target_) {
-throw new Error('Function internalCompile is missing on this target in sync context.');
+$firefly_compiler["buildViaBuildSystem_$"](buildSystem_, ff_core_BuildSystem.internalPath_(buildSystem_, buildSystem_["fireflyPath_"]), ff_core_Path.Path_base(mainFile_), target_, $task)
 }
 
 export function internalMainPackagePair_(buildSystem_) {
-throw new Error('Function internalMainPackagePair is missing on this target in sync context.');
+return ff_core_Pair.Pair(buildSystem_["mainPackagePair_"]["group_"], buildSystem_["mainPackagePair_"]["name_"])
 }
 
 export async function internalCallEsBuild_$(self_, mainJsFile_, outputPath_, minify_, sourceMap_, $task) {
-
-        const esbuild = import$0
-        return await esbuild.build({
-            stdin: {contents: `import {$run$} from './${mainJsFile_}';`, resolveDir: '.'},
-            bundle: true,
-            minify: minify_,
-            sourcemap: sourceMap_,
-            platform: 'browser',
-            target: 'es2017',
-            external: ['../../../node_modules/*'], // TODO
-            outfile: outputPath_
-        })
-    
+const esbuild_ = import$0;
+esbuild_.build({stdin: {contents: (("import {$run$} from './" + mainJsFile_) + "';"), resolveDir: "."}, bundle: true, minify: minify_, sourcemap: sourceMap_, platform: "browser", target: "es2017", external: ["../../../node_modules/*"], outfile: outputPath_})
 }
 
 export async function internalNodeCallEsBuild_$(self_, mainJsFile_, outputPath_, minify_, $task) {
-
-        const esbuild = import$0
-        return await esbuild.build({
-            entryPoints: [mainJsFile_],
-            bundle: true,
-            minify: minify_,
-            sourcemap: true,
-            platform: 'node',
-            target: 'es6',
-            external: ['../../../node_modules/*'], // TODO
-            outfile: outputPath_
-        })
-    
+const esbuild_ = import$0;
+esbuild_.build({entryPoints: [mainJsFile_], bundle: true, minify: minify_, sourcemap: true, platform: "node", target: "es2017", external: ["../../../node_modules/*"], outfile: outputPath_})
 }
 
 export async function internalListDirectory_$(path_, $task) {
@@ -194,21 +179,16 @@ return (await ff_core_Path.Path_readStream$(file_, $task))
 }
 
 export async function internalPath_$(buildSystem_, absoluteOrRelative_, $task) {
-
-        return absoluteOrRelative_
-    
+const nodePath_ = import$1;
+return ff_core_Path.Path(nodePath_.resolve(absoluteOrRelative_))
 }
 
 export async function internalCompile_$(buildSystem_, mainFile_, target_, $task) {
-
-        return await $firefly_compiler.buildViaBuildSystem_$(buildSystem_, buildSystem_.fireflyPath_, mainFile_, target_, $task)
-    
+(await $firefly_compiler["buildViaBuildSystem_$"](buildSystem_, (await ff_core_BuildSystem.internalPath_$(buildSystem_, buildSystem_["fireflyPath_"], $task)), (await ff_core_Path.Path_base$(mainFile_, $task)), target_, $task))
 }
 
 export async function internalMainPackagePair_$(buildSystem_, $task) {
-
-        return {first_: buildSystem_.mainPackagePair_.group_, second_: buildSystem_.mainPackagePair_.name_}
-    
+return ff_core_Pair.Pair(buildSystem_["mainPackagePair_"]["group_"], buildSystem_["mainPackagePair_"]["name_"])
 }
 
 export function BuildSystem_compileForBrowser(self_, mainFile_) {
@@ -219,11 +199,11 @@ return ff_core_BuildSystem.BrowserCode(mainPackagePair_.first_, mainPackagePair_
 }
 
 export function BuildSystem_buildMode(self_) {
-throw new Error('Function BuildSystem_buildMode is missing on this target in sync context.');
+return (!(!self_["buildMode_"]))
 }
 
 export function BuildSystem_setAssets(self_, assetSystem_) {
-throw new Error('Function BuildSystem_setAssets is missing on this target in sync context.');
+self_["assets_"] = assetSystem_
 }
 
 export function BuildSystem_packageAssets(self_) {
@@ -236,15 +216,15 @@ return ff_core_Core.panic_("dependencyAssets not yet implemented")
 }
 
 export function BuildSystem_arguments(self_) {
-throw new Error('Function BuildSystem_arguments is missing on this target in sync context.');
+return self_["array_"]
 }
 
 export function BuildSystem_mainTask(self_) {
-throw new Error('Function BuildSystem_mainTask is missing on this target in sync context.');
+return self_["task_"]
 }
 
 export function BuildSystem_crypto(self_) {
-throw new Error('Function BuildSystem_crypto is missing on this target in sync context.');
+return crypto
 }
 
 export async function BuildSystem_compileForBrowser$(self_, mainFile_, $task) {
@@ -255,11 +235,11 @@ return ff_core_BuildSystem.BrowserCode(mainPackagePair_.first_, mainPackagePair_
 }
 
 export async function BuildSystem_buildMode$(self_, $task) {
-return !!self_.buildMode_
+return (!(!self_["buildMode_"]))
 }
 
 export async function BuildSystem_setAssets$(self_, assetSystem_, $task) {
-self_.assets_ = assetSystem_
+self_["assets_"] = assetSystem_
 }
 
 export async function BuildSystem_packageAssets$(self_, $task) {
@@ -272,15 +252,15 @@ return ff_core_Core.panic_("dependencyAssets not yet implemented")
 }
 
 export async function BuildSystem_arguments$(self_, $task) {
-return self_.array_
+return self_["array_"]
 }
 
 export async function BuildSystem_mainTask$(self_, $task) {
-return self_.task_
+return self_["task_"]
 }
 
 export async function BuildSystem_crypto$(self_, $task) {
-return (typeof globalThis !== 'undefined' ? globalThis : window).crypto
+return crypto
 }
 
 export function BrowserCode_assets(self_) {
@@ -294,10 +274,10 @@ const mainJsFile_ = ((((((prefix_ + "/") + self_.packageGroup_) + "/") + self_.p
 const mainDirectory_ = ff_core_Option.Option_grab(ff_core_Path.Path_parent(self_.mainFile_));
 const file_ = (prefix_ + "/Main.bundle.js");
 ff_core_BuildSystem.internalCallEsBuild_(self_, mainJsFile_, file_, minify_, sourceMap_);
-const assets_ = ff_core_AssetSystem.AssetSystem(ff_core_List.List_toMap([ff_core_Pair.Pair(ff_core_String.String_dropFirst(file_, ff_core_String.String_size(prefix_)), (() => {
+const assets_ = ff_core_AssetSystem.AssetSystem(ff_core_List.List_toMap([ff_core_Pair.Pair(ff_core_String.String_dropFirst(file_, prefix_.length), (() => {
 return ff_core_Path.Path_readStream(ff_core_Path.Path_path(mainDirectory_, file_))
 })), ...(sourceMap_
-? [ff_core_Pair.Pair((ff_core_String.String_dropFirst(file_, ff_core_String.String_size(prefix_)) + ".map"), (() => {
+? [ff_core_Pair.Pair((ff_core_String.String_dropFirst(file_, prefix_.length) + ".map"), (() => {
 return ff_core_Path.Path_readStream(ff_core_Path.Path_path(mainDirectory_, (file_ + ".map")))
 }))]
 : [])], ff_core_Ordering.ff_core_Ordering_Order$ff_core_String_String));
@@ -315,10 +295,10 @@ const mainJsFile_ = ((((((prefix_ + "/") + self_.packageGroup_) + "/") + self_.p
 const mainDirectory_ = ff_core_Option.Option_grab((await ff_core_Path.Path_parent$(self_.mainFile_, $task)));
 const file_ = (prefix_ + "/Main.bundle.js");
 (await ff_core_BuildSystem.internalCallEsBuild_$(self_, mainJsFile_, file_, minify_, sourceMap_, $task));
-const assets_ = ff_core_AssetSystem.AssetSystem(ff_core_List.List_toMap([ff_core_Pair.Pair(ff_core_String.String_dropFirst(file_, ff_core_String.String_size(prefix_)), (async ($task) => {
+const assets_ = ff_core_AssetSystem.AssetSystem(ff_core_List.List_toMap([ff_core_Pair.Pair(ff_core_String.String_dropFirst(file_, prefix_.length), (async ($task) => {
 return (await ff_core_Path.Path_readStream$((await ff_core_Path.Path_path$(mainDirectory_, file_, $task)), $task))
 })), ...(sourceMap_
-? [ff_core_Pair.Pair((ff_core_String.String_dropFirst(file_, ff_core_String.String_size(prefix_)) + ".map"), (async ($task) => {
+? [ff_core_Pair.Pair((ff_core_String.String_dropFirst(file_, prefix_.length) + ".map"), (async ($task) => {
 return (await ff_core_Path.Path_readStream$((await ff_core_Path.Path_path$(mainDirectory_, (file_ + ".map"), $task)), $task))
 }))]
 : [])], ff_core_Ordering.ff_core_Ordering_Order$ff_core_String_String));

package/output/js/ff/core/Channel.mjs

@@ -42,6 +42,8 @@ import * as ff_core_Int from "../../ff/core/Int.mjs"
 
 import * as ff_core_IntMap from "../../ff/core/IntMap.mjs"
 
+import * as ff_core_Js from "../../ff/core/Js.mjs"
+
 import * as ff_core_JsSystem from "../../ff/core/JsSystem.mjs"
 
 import * as ff_core_JsValue from "../../ff/core/JsValue.mjs"
@@ -68,6 +70,8 @@ import * as ff_core_Pair from "../../ff/core/Pair.mjs"
 
 import * as ff_core_Path from "../../ff/core/Path.mjs"
 
+import * as ff_core_Queue from "../../ff/core/Queue.mjs"
+
 import * as ff_core_Random from "../../ff/core/Random.mjs"
 
 import * as ff_core_Serializable from "../../ff/core/Serializable.mjs"
@@ -90,121 +94,270 @@ import * as ff_core_Try from "../../ff/core/Try.mjs"
 
 import * as ff_core_Unit from "../../ff/core/Unit.mjs"
 
-import * as ff_core_UnsafeJs from "../../ff/core/UnsafeJs.mjs"
-
 // type Channel
-
+export function Channel(capacity_, buffer_, readers_, writers_) {
+return {capacity_, buffer_, readers_, writers_};
+}
 
 // type ChannelAction
-
+export function ChannelAction(channel_, body_, message_, previous_) {
+return {channel_, body_, message_, previous_};
+}
 
 
 
 export function readOr_(channel_, body_) {
-throw new Error('Function readOr is missing on this target in sync context.');
+return ff_core_Channel.ChannelAction(channel_, body_, ff_core_Option.None(), ff_core_Option.None())
 }
 
 export function writeOr_(channel_, message_, body_) {
-throw new Error('Function writeOr is missing on this target in sync context.');
+return ff_core_Channel.ChannelAction(channel_, body_, ff_core_Option.Some(message_), ff_core_Option.None())
 }
 
 export function internalRunChannelAction_(action_, mode_) {
-throw new Error('Function internalRunChannelAction is missing on this target in sync context.');
+;
+const actions_ = ff_core_List.List_toArray([]);
+function findActions_(action_) {
+actions_.array.push(action_);
+{
+const if_o = action_.previous_
+if(if_o.Some) {
+const _w1 = if_o.value_;
+findActions_(_w1)
+}
+}
+}
+findActions_(action_);
+let foundPromise_ = ff_core_Option.None();
+for(let for_a = actions_.array, for_i = 0, for_l = for_a.length; for_i < for_l; for_i++) {
+const action_ = for_a[for_i];
+do {
+const _1 = action_.message_;
+if(_1.Some) {
+const message_ = _1.value_;
+if((action_.channel_.readers_.size !== 0)) {
+const reader_ = action_.channel_.readers_.values().next().value;
+action_.channel_.readers_.delete(reader_);
+reader_.resolve(message_);
+foundPromise_ = ff_core_Option.Some(action_.body_($task))
+break
+}
+}
+if(_1.Some) {
+const message_ = _1.value_;
+if((action_.channel_.buffer_.array.length < action_.channel_.capacity_)) {
+action_.channel_.buffer_.array.push(message_);
+foundPromise_ = ff_core_Option.Some(action_.body_($task))
+break
+}
+}
+if(_1.Some) {
+
+break
+}
+if(_1.None && (action_.channel_.buffer_.array.length !== 0)) {
+ff_core_Array.Array_reverse(action_.channel_.buffer_);
+const message_ = ff_core_Array.Array_pop(action_.channel_.buffer_);
+ff_core_Array.Array_reverse(action_.channel_.buffer_);
+foundPromise_ = ff_core_Option.Some(action_.body_(message_, $task))
+break
+}
+if(_1.None && (action_.channel_.writers_.size !== 0)) {
+const writer_ = action_.channel_.writers_.values().next().value;
+action_.channel_.writers_.delete(writer_);
+writer_.resolve();
+foundPromise_ = ff_core_Option.Some(action_.body_(writer_.message, $task))
+break
+}
+{
+
+}
+} while(false);
+if(!ff_core_Option.Option_isEmpty(foundPromise_)) break
+};
+return ff_core_Option.Option_else(ff_core_Option.Option_map(foundPromise_, ((_w1) => {
+return _w1
+})), (() => {
+if(ff_core_Option.Option_any(mode_, ((_w1) => {
+return ff_core_Option.Option_isEmpty(_w1.second_)
+}))) {
+const makePromise_ = ff_core_Option.Option_grab(mode_).first_;
+return makePromise_()
+} else {
+const body_ = ff_core_Js.awaitCancellablePromise_(((resolve_, reject_, onSettled_) => {
+{
+const if_o = mode_
+if(if_o.Some) {
+const m_ = if_o.value_;
+const timeout_ = setTimeout((() => {
+return resolve_(m_.first_)
+}), (ff_core_Option.Option_grab(m_.second_) * 1000.0));
+onSettled_(((_) => {
+clearTimeout(timeout_)
+}))
+}
+};
+for(let for_a = actions_.array, for_i = 0, for_l = for_a.length; for_i < for_l; for_i++) {
+const action_ = for_a[for_i];
+do {
+const _1 = action_.message_;
+if(_1.Some) {
+const message_ = _1.value_;
+const writer_ = {resolve: (() => {
+return resolve_((() => {
+return action_.body_($task)
+}))
+}), message: message_};
+action_.channel_.writers_.add(writer_);
+onSettled_(((_) => {
+action_.channel_.writers_.delete(writer_)
+}))
+break
+}
+{
+const reader_ = {resolve: ((m_) => {
+return resolve_((() => {
+return action_.body_(m_, $task)
+}))
+})};
+action_.channel_.readers_.add(reader_);
+onSettled_(((_) => {
+action_.channel_.readers_.delete(reader_)
+}))
+}
+} while(false)
+}
+}));
+return body_()
+}
+}))
 }
 
 export async function readOr_$(channel_, body_, $task) {
-return {channel: channel_, body: body_, previous: null}
+return ff_core_Channel.ChannelAction(channel_, body_, ff_core_Option.None(), ff_core_Option.None())
 }
 
 export async function writeOr_$(channel_, message_, body_, $task) {
-return {channel: channel_, body: body_, message: message_, previous: null}
+return ff_core_Channel.ChannelAction(channel_, body_, ff_core_Option.Some(message_), ff_core_Option.None())
 }
 
 export async function internalRunChannelAction_$(action_, mode_, $task) {
-
-        ff_core_Task.Task_throwIfAborted($task)
-
-        // Convert the linked actions into an array.
-        let actions = []
-        while(action_ != null) {
-            actions.push(action_)
-            action_ = action_.previous
-        }
-        actions.reverse()
-
-        // If any reads or writes can be done immediately, do the first one and return.
-        for(let action of actions) {
-            if(action.hasOwnProperty("message")) {
-                if(action.channel.readers.size != 0) {
-                    let reader = action.channel.readers.values().next().value
-                    action.channel.readers.delete(reader)
-                    reader.resolve(action.message)
-                    return await action.body($task)
-                } else if(action.channel.buffer.length < action.channel.capacity) {
-                    action.channel.buffer.push(action.message)
-                    return await action.body($task)
-                }
-            } else {
-                if(action.channel.buffer.length != 0) {
-                    return await action.body(action.channel.buffer.shift(), $task)
-                } else if(action.channel.writers.size != 0) {
-                    let writer = action.channel.writers.values().next().value
-                    action.channel.writers.delete(writer)
-                    writer.resolve()
-                    return await action.body(writer.message, $task)
-                }
-            }
-        }
-
-        // If there's an "immediately(body)" action, do that now.
-        if(mode_.value_ && mode_.value_.second_.value_ == null) return await mode_.value_.first_($task)
-
-        // Otherwise, start waiting for one of the readers or writers (or timeout(body), or cancellation) to happen.
-        let abort = null
-        let finish = null
-        let cleanups = []
-        function doCleanup() {
-            for(let cleanup of cleanups) cleanup()
-        }
-        let promise = new Promise((resolve, reject) => {
-            if(mode_.value_) finish = () => {doCleanup(); resolve(() => mode_.value_.first_($task))}
-            abort = () => {doCleanup(); reject($task.controller.signal.reason)}
-            for(let action of actions) {
-                if(action.hasOwnProperty("message")) {
-                    let writer = {
-                        resolve: () => {
-                            doCleanup()
-                            resolve(() => action.body($task))
-                        },
-                        message: action.message
-                    }
-                    cleanups.push(() => action.channel.writers.delete(writer))
-                    action.channel.writers.add(writer)
-                } else {
-                    let reader = {
-                        resolve: m => {
-                            doCleanup()
-                            resolve(() => action.body(m, $task))
-                        }
-                    }
-                    cleanups.push(() => action.channel.readers.delete(reader))
-                    action.channel.readers.add(reader)
-                }
-            }
-        })
-        let timeout = null
-        try {
-            $task.controller.signal.addEventListener('abort', abort)
-            if(finish != null) timeout = setTimeout(finish, mode_.value_.second_.value_ * 1000)
-            let body = await promise
-            if(timeout != null) { clearTimeout(timeout); timeout = null }
-            return await body()
-        } finally {
-            if(timeout != null) clearTimeout(timeout)
-            $task.controller.signal.removeEventListener('abort', abort)
-            if($task.controller.signal.aborted) $task.controller = new AbortController()
-        }
-    
+ff_core_Task.Task_throwIfAborted($task);
+const actions_ = ff_core_List.List_toArray([]);
+function findActions_(action_) {
+actions_.array.push(action_);
+{
+const if_o = action_.previous_
+if(if_o.Some) {
+const _w1 = if_o.value_;
+findActions_(_w1)
+}
+}
+}
+findActions_(action_);
+let foundPromise_ = ff_core_Option.None();
+for(let for_a = actions_.array, for_i = 0, for_l = for_a.length; for_i < for_l; for_i++) {
+const action_ = for_a[for_i];
+do {
+const _1 = action_.message_;
+if(_1.Some) {
+const message_ = _1.value_;
+if((action_.channel_.readers_.size !== 0)) {
+const reader_ = action_.channel_.readers_.values().next().value;
+action_.channel_.readers_.delete(reader_);
+reader_.resolve(message_);
+foundPromise_ = ff_core_Option.Some(action_.body_($task))
+break
+}
+}
+if(_1.Some) {
+const message_ = _1.value_;
+if((action_.channel_.buffer_.array.length < action_.channel_.capacity_)) {
+action_.channel_.buffer_.array.push(message_);
+foundPromise_ = ff_core_Option.Some(action_.body_($task))
+break
+}
+}
+if(_1.Some) {
+
+break
+}
+if(_1.None && (action_.channel_.buffer_.array.length !== 0)) {
+ff_core_Array.Array_reverse(action_.channel_.buffer_);
+const message_ = ff_core_Array.Array_pop(action_.channel_.buffer_);
+ff_core_Array.Array_reverse(action_.channel_.buffer_);
+foundPromise_ = ff_core_Option.Some(action_.body_(message_, $task))
+break
+}
+if(_1.None && (action_.channel_.writers_.size !== 0)) {
+const writer_ = action_.channel_.writers_.values().next().value;
+action_.channel_.writers_.delete(writer_);
+writer_.resolve();
+foundPromise_ = ff_core_Option.Some(action_.body_(writer_.message, $task))
+break
+}
+{
+
+}
+} while(false);
+if(!ff_core_Option.Option_isEmpty(foundPromise_)) break
+};
+return (await ff_core_Option.Option_else$((await ff_core_Option.Option_map$(foundPromise_, (async (_w1, $task) => {
+return (await _w1)
+}), $task)), (async ($task) => {
+if(ff_core_Option.Option_any(mode_, ((_w1) => {
+return ff_core_Option.Option_isEmpty(_w1.second_)
+}))) {
+const makePromise_ = ff_core_Option.Option_grab(mode_).first_;
+return (await (await makePromise_($task)))
+} else {
+const body_ = (await ff_core_Js.awaitCancellablePromise_$(((resolve_, reject_, onSettled_) => {
+{
+const if_o = mode_
+if(if_o.Some) {
+const m_ = if_o.value_;
+const timeout_ = setTimeout((() => {
+return resolve_(m_.first_)
+}), (ff_core_Option.Option_grab(m_.second_) * 1000.0));
+onSettled_(((_) => {
+clearTimeout(timeout_)
+}))
+}
+};
+for(let for_a = actions_.array, for_i = 0, for_l = for_a.length; for_i < for_l; for_i++) {
+const action_ = for_a[for_i];
+do {
+const _1 = action_.message_;
+if(_1.Some) {
+const message_ = _1.value_;
+const writer_ = {resolve: (() => {
+return resolve_((async ($task) => {
+return action_.body_($task)
+}))
+}), message: message_};
+action_.channel_.writers_.add(writer_);
+onSettled_(((_) => {
+action_.channel_.writers_.delete(writer_)
+}))
+break
+}
+{
+const reader_ = {resolve: ((m_) => {
+return resolve_((async ($task) => {
+return action_.body_(m_, $task)
+}))
+})};
+action_.channel_.readers_.add(reader_);
+onSettled_(((_) => {
+action_.channel_.readers_.delete(reader_)
+}))
+}
+} while(false)
+}
+}), $task));
+return (await body_($task))
+}
+}), $task))
 }
 
 export function Channel_read(self_) {
@@ -232,11 +385,11 @@ export async function Channel_write$(self_, message_, $task) {
 }
 
 export function ChannelAction_readOr(self_, channel_, body_) {
-throw new Error('Function ChannelAction_readOr is missing on this target in sync context.');
+return ff_core_Channel.ChannelAction(channel_, body_, ff_core_Option.None(), ff_core_Option.Some(self_))
 }
 
 export function ChannelAction_writeOr(self_, channel_, message_, body_) {
-throw new Error('Function ChannelAction_writeOr is missing on this target in sync context.');
+return ff_core_Channel.ChannelAction(channel_, body_, ff_core_Option.Some(message_), ff_core_Option.Some(self_))
 }
 
 export function ChannelAction_wait(self_) {
@@ -252,11 +405,11 @@ return ff_core_Channel.internalRunChannelAction_(self_, ff_core_Option.Some(ff_c
 }
 
 export async function ChannelAction_readOr$(self_, channel_, body_, $task) {
-return {channel: channel_, body: body_, previous: self_}
+return ff_core_Channel.ChannelAction(channel_, body_, ff_core_Option.None(), ff_core_Option.Some(self_))
 }
 
 export async function ChannelAction_writeOr$(self_, channel_, message_, body_, $task) {
-return {channel: channel_, body: body_, message: message_, previous: self_}
+return ff_core_Channel.ChannelAction(channel_, body_, ff_core_Option.Some(message_), ff_core_Option.Some(self_))
 }
 
 export async function ChannelAction_wait$(self_, $task) {

package/output/js/ff/core/Char.mjs

@@ -42,6 +42,8 @@ import * as ff_core_Int from "../../ff/core/Int.mjs"
 
 import * as ff_core_IntMap from "../../ff/core/IntMap.mjs"
 
+import * as ff_core_Js from "../../ff/core/Js.mjs"
+
 import * as ff_core_JsSystem from "../../ff/core/JsSystem.mjs"
 
 import * as ff_core_JsValue from "../../ff/core/JsValue.mjs"
@@ -68,6 +70,8 @@ import * as ff_core_Pair from "../../ff/core/Pair.mjs"
 
 import * as ff_core_Path from "../../ff/core/Path.mjs"
 
+import * as ff_core_Queue from "../../ff/core/Queue.mjs"
+
 import * as ff_core_Random from "../../ff/core/Random.mjs"
 
 import * as ff_core_Serializable from "../../ff/core/Serializable.mjs"
@@ -90,8 +94,6 @@ import * as ff_core_Try from "../../ff/core/Try.mjs"
 
 import * as ff_core_Unit from "../../ff/core/Unit.mjs"
 
-import * as ff_core_UnsafeJs from "../../ff/core/UnsafeJs.mjs"
-
 // newtype Char
 
 
@@ -145,7 +147,7 @@ return ((self_ >= 48) && (self_ <= 57))
 }
 
 export async function Char_toString$(self_, $task) {
-throw new Error('Function Char_toString is missing on this target in async context.');
+return String.fromCharCode(self_)
 }