@effectionx/worker 0.1.1

package/script/deps/jsr.io/@std/internal/1.0.6/styles.js

@@ -0,0 +1,242 @@
+"use strict";
+// Copyright 2018-2025 the Deno authors. MIT license.
+// This module is browser compatible.
+// A module to print ANSI terminal colors. Inspired by chalk, kleur, and colors
+// on npm.
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bold = bold;
+exports.red = red;
+exports.green = green;
+exports.yellow = yellow;
+exports.white = white;
+exports.gray = gray;
+exports.brightBlack = brightBlack;
+exports.bgRed = bgRed;
+exports.bgGreen = bgGreen;
+exports.stripAnsiCode = stripAnsiCode;
+// This code is vendored from `fmt/colors.ts`.
+// deno-lint-ignore no-explicit-any
+const dntShim = __importStar(require("../../../../../_dnt.shims.js"));
+const { Deno } = dntShim.dntGlobalThis;
+const noColor = typeof Deno?.noColor === "boolean"
+    ? Deno.noColor
+    : false;
+const enabled = !noColor;
+function code(open, close) {
+    return {
+        open: `\x1b[${open.join(";")}m`,
+        close: `\x1b[${close}m`,
+        regexp: new RegExp(`\\x1b\\[${close}m`, "g"),
+    };
+}
+function run(str, code) {
+    return enabled
+        ? `${code.open}${str.replace(code.regexp, code.open)}${code.close}`
+        : str;
+}
+/**
+ * Sets the style of text to be printed to bold.
+ *
+ * Disable by setting the `NO_COLOR` environmental variable.
+ *
+ * @param str Text to make bold
+ *
+ * @returns Bold text for printing
+ *
+ * @example Usage
+ * ```ts no-assert
+ * import { bold } from "@std/internal/styles";
+ *
+ * console.log(bold("Hello, world!")); // Prints "Hello, world!" in bold
+ * ```
+ */
+function bold(str) {
+    return run(str, code([1], 22));
+}
+/**
+ * Sets the color of text to be printed to red.
+ *
+ * Disable by setting the `NO_COLOR` environmental variable.
+ *
+ * @param str Text to make red
+ *
+ * @returns Red text for printing
+ *
+ * @example Usage
+ * ```ts no-assert
+ * import { red } from "@std/internal/styles";
+ *
+ * console.log(red("Hello, world!")); // Prints "Hello, world!" in red
+ * ```
+ */
+function red(str) {
+    return run(str, code([31], 39));
+}
+/**
+ * Sets the color of text to be printed to green.
+ *
+ * Disable by setting the `NO_COLOR` environmental variable.
+ *
+ * @param str Text to make green
+ *
+ * @returns Green text for print
+ *
+ * @example Usage
+ * ```ts no-assert
+ * import { green } from "@std/internal/styles";
+ *
+ * console.log(green("Hello, world!")); // Prints "Hello, world!" in green
+ * ```
+ */
+function green(str) {
+    return run(str, code([32], 39));
+}
+/**
+ * Sets the color of text to be printed to yellow.
+ *
+ * Disable by setting the `NO_COLOR` environmental variable.
+ *
+ * @param str Text to make yellow
+ *
+ * @returns Yellow text for print
+ *
+ * @example Usage
+ * ```ts no-assert
+ * import { yellow } from "@std/internal/styles";
+ *
+ * console.log(yellow("Hello, world!")); // Prints "Hello, world!" in yellow
+ * ```
+ */
+function yellow(str) {
+    return run(str, code([33], 39));
+}
+/**
+ * Sets the color of text to be printed to white.
+ *
+ * @param str Text to make white
+ *
+ * @returns White text for print
+ *
+ * @example Usage
+ * ```ts no-assert
+ * import { white } from "@std/internal/styles";
+ *
+ * console.log(white("Hello, world!")); // Prints "Hello, world!" in white
+ * ```
+ */
+function white(str) {
+    return run(str, code([37], 39));
+}
+/**
+ * Sets the color of text to be printed to gray.
+ *
+ * @param str Text to make gray
+ *
+ * @returns Gray text for print
+ *
+ * @example Usage
+ * ```ts no-assert
+ * import { gray } from "@std/internal/styles";
+ *
+ * console.log(gray("Hello, world!")); // Prints "Hello, world!" in gray
+ * ```
+ */
+function gray(str) {
+    return brightBlack(str);
+}
+/**
+ * Sets the color of text to be printed to bright-black.
+ *
+ * @param str Text to make bright-black
+ *
+ * @returns Bright-black text for print
+ *
+ * @example Usage
+ * ```ts no-assert
+ * import { brightBlack } from "@std/internal/styles";
+ *
+ * console.log(brightBlack("Hello, world!")); // Prints "Hello, world!" in bright-black
+ * ```
+ */
+function brightBlack(str) {
+    return run(str, code([90], 39));
+}
+/**
+ * Sets the background color of text to be printed to red.
+ *
+ * @param str Text to make its background red
+ *
+ * @returns Red background text for print
+ *
+ * @example Usage
+ * ```ts no-assert
+ * import { bgRed } from "@std/internal/styles";
+ *
+ * console.log(bgRed("Hello, world!")); // Prints "Hello, world!" with red background
+ * ```
+ */
+function bgRed(str) {
+    return run(str, code([41], 49));
+}
+/**
+ * Sets the background color of text to be printed to green.
+ *
+ * @param str Text to make its background green
+ *
+ * @returns Green background text for print
+ *
+ * @example Usage
+ * ```ts no-assert
+ * import { bgGreen } from "@std/internal/styles";
+ *
+ * console.log(bgGreen("Hello, world!")); // Prints "Hello, world!" with green background
+ * ```
+ */
+function bgGreen(str) {
+    return run(str, code([42], 49));
+}
+// https://github.com/chalk/ansi-regex/blob/02fa893d619d3da85411acc8fd4e2eea0e95a9d9/index.js
+const ANSI_PATTERN = new RegExp([
+    "[\\u001B\\u009B][[\\]()#;?]*(?:(?:(?:(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]+)*|[a-zA-Z\\d]+(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]*)*)?\\u0007)",
+    "(?:(?:\\d{1,4}(?:;\\d{0,4})*)?[\\dA-PR-TXZcf-nq-uy=><~]))",
+].join("|"), "g");
+/**
+ * Remove ANSI escape codes from the string.
+ *
+ * @param string Text to remove ANSI escape codes from
+ *
+ * @returns Text without ANSI escape codes
+ *
+ * @example Usage
+ * ```ts no-assert
+ * import { red, stripAnsiCode } from "@std/internal/styles";
+ *
+ * console.log(stripAnsiCode(red("Hello, world!"))); // Prints "Hello, world!"
+ * ```
+ */
+function stripAnsiCode(string) {
+    return string.replace(ANSI_PATTERN, "");
+}

package/script/deps/jsr.io/@std/internal/1.0.6/types.d.ts

@@ -0,0 +1,16 @@
+/** Ways that lines in a diff can be different. */
+export type DiffType = "removed" | "common" | "added";
+/**
+ * Represents the result of a diff operation.
+ *
+ * @typeParam T The type of the value in the diff result.
+ */
+export interface DiffResult<T> {
+    /** The type of the diff. */
+    type: DiffType;
+    /** The value of the diff. */
+    value: T;
+    /** The details of the diff. */
+    details?: DiffResult<T>[];
+}
+//# sourceMappingURL=types.d.ts.map

package/script/deps/jsr.io/@std/internal/1.0.6/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/internal/1.0.6/types.ts"],"names":[],"mappings":"AAGA,kDAAkD;AAClD,MAAM,MAAM,QAAQ,GAAG,SAAS,GAAG,QAAQ,GAAG,OAAO,CAAC;AAEtD;;;;GAIG;AACH,MAAM,WAAW,UAAU,CAAC,CAAC;IAC3B,4BAA4B;IAC5B,IAAI,EAAE,QAAQ,CAAC;IACf,6BAA6B;IAC7B,KAAK,EAAE,CAAC,CAAC;IACT,+BAA+B;IAC/B,OAAO,CAAC,EAAE,UAAU,CAAC,CAAC,CAAC,EAAE,CAAC;CAC3B"}

package/script/deps/jsr.io/@std/internal/1.0.6/types.js

@@ -0,0 +1,4 @@
+"use strict";
+// Copyright 2018-2025 the Deno authors. MIT license.
+// This module is browser compatible.
+Object.defineProperty(exports, "__esModule", { value: true });

package/script/mod.d.ts

@@ -0,0 +1,2 @@
+export * from "./worker.js";
+//# sourceMappingURL=mod.d.ts.map

package/script/mod.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mod.d.ts","sourceRoot":"","sources":["../src/mod.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAC"}

package/script/mod.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./worker.js"), exports);

package/script/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "commonjs"
+}

package/script/worker.d.ts

@@ -0,0 +1,135 @@
+import { type Operation } from "effection";
+export interface WorkerResource<TSend, TRecv, TReturn> extends Operation<TReturn> {
+    send(data: TSend): Operation<TRecv>;
+}
+/**
+ * Object that represents messages the main thread
+ * sends to the worker. It provides function for
+ * handling messages.
+ *
+ * @template TSend - value main thread will send to the worker
+ * @template TRecv - value main thread will receive from the worker
+ */
+export interface WorkerMessages<TSend, TRecv> {
+    forEach(fn: (message: TSend) => Operation<TRecv>): Operation<void>;
+}
+/**
+ * Argument received by workerMain function
+ *
+ * @template TSend - value main thread will send to the worker
+ * @template TRecv - value main thread will receive from the worker
+ * @template TData - data passed from the main thread to the worker during initialization
+ */
+export interface WorkerMainOptions<TSend, TRecv, TData> {
+    /**
+     * Namespace that provides APIs for working with incoming messages
+     */
+    messages: WorkerMessages<TSend, TRecv>;
+    /**
+     * Initial data received by the worker from the main thread used for initialization.
+     */
+    data: TData;
+}
+/**
+ * Entrypoint used in the worker that estaliblishes communication
+ * with the main thread. It can be used to return a value,
+ * respond to messages or both.
+ *
+ * @example Returning a value
+ * ```ts
+ * import { workerMain } from "../worker.ts";
+ *
+ * await workerMain(function* ({ data }) {
+ *  return data;
+ * });
+ * ```
+ *
+ * @example Responding to messages
+ * ```ts
+ * import { workerMain } from "../worker.ts";
+ *
+ * await workerMain(function* ({ messages }) {
+ *  yield* messages.forEach(function* (message) {
+ *    return message;
+ *  });
+ * });
+ * ```
+ *
+ * @example Responding to messages and return a value
+ * ```ts
+ * import { workerMain } from "../worker.ts";
+ *
+ * await workerMain<number, number, number, number>(
+ *   function* ({ messages, data: initial }) {
+ *     let counter = initial;
+ *
+ *     yield* messages.forEach(function* (message) {
+ *       counter += message;
+ *       return counter; // returns a value after each message
+ *     });
+ *
+ *     return counter; // returns the final value
+ *   },
+ * );
+ * ```
+ *
+ * @template TSend - value main thread will send to the worker
+ * @template TRecv - value main thread will receive from the worker
+ * @template TReturn - worker operation return value
+ * @template TData - data passed from the main thread to the worker during initialization
+ * @param {(options: WorkerMainOptions<TSend, TRecv, TData>) => Operation<TReturn>} body
+ * @returns {Promise<void>}
+ */
+export declare function workerMain<TSend, TRecv, TReturn, TData>(body: (options: WorkerMainOptions<TSend, TRecv, TData>) => Operation<TReturn>): Promise<void>;
+/**
+ * Use on the main thread to create and exeecute a well behaved web worker.
+ *
+ * @example Compute a single value
+ * ```ts
+ * import { run } from "effection";
+ * import { useWorker } from "@effectionx/worker"
+ *
+ * await run(function*() {
+ *    const worker = yield* useWorker("script.ts", { type: "module" });
+ *
+ *    try {
+ *      const result = yield* worker;
+ *    } catch (e) {
+ *      console.error(e);
+ *    }
+ * });
+ * ```
+ *
+ * @example Compute multipe values
+ * ```ts
+ * import { run } from "effection";
+ * import { useWorker } from "@effectionx/worker"
+ *
+ * await run(function*() {
+ *    const worker = yield* useWorker("script.ts", { type: "module" });
+ *
+ *    try {
+ *      const result1 = yield* worker.send("Tom");
+ *      const result2 = yield* worker.send("Dick");
+ *      const result2 = yield* worker.send("Harry");
+ *
+ *      // get the last result
+ *      const finalResult = yield* worker;
+ *    } catch (e) {
+ *      console.error(e);
+ *    }
+ * });
+ * ```
+ *
+ * @param url URL or string of script
+ * @param options WorkerOptions
+ * @template TSend - value main thread will send to the worker
+ * @template TRecv - value main thread will receive from the worker
+ * @template TReturn - worker operation return value
+ * @template TData - data passed from the main thread to the worker during initialization
+ * @returns {Operation<WorkerResource<TSend, TRecv>>}
+ */
+export declare function useWorker<TSend, TRecv, TReturn, TData>(url: string | URL, options?: WorkerOptions & {
+    data?: TData;
+}): Operation<WorkerResource<TSend, TRecv, TReturn>>;
+//# sourceMappingURL=worker.d.ts.map

package/script/worker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"worker.d.ts","sourceRoot":"","sources":["../src/worker.ts"],"names":[],"mappings":"AACA,OAAO,EAQL,KAAK,SAAS,EAMf,MAAM,WAAW,CAAC;AAEnB,MAAM,WAAW,cAAc,CAAC,KAAK,EAAE,KAAK,EAAE,OAAO,CACnD,SAAQ,SAAS,CAAC,OAAO,CAAC;IAC1B,IAAI,CAAC,IAAI,EAAE,KAAK,GAAG,SAAS,CAAC,KAAK,CAAC,CAAC;CACrC;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,cAAc,CAAC,KAAK,EAAE,KAAK;IAC1C,OAAO,CAAC,EAAE,EAAE,CAAC,OAAO,EAAE,KAAK,KAAK,SAAS,CAAC,KAAK,CAAC,GAAG,SAAS,CAAC,IAAI,CAAC,CAAC;CACpE;AAED;;;;;;GAMG;AACH,MAAM,WAAW,iBAAiB,CAAC,KAAK,EAAE,KAAK,EAAE,KAAK;IACpD;;OAEG;IACH,QAAQ,EAAE,cAAc,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;IACvC;;OAEG;IACH,IAAI,EAAE,KAAK,CAAC;CACb;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiDG;AACH,wBAAsB,UAAU,CAAC,KAAK,EAAE,KAAK,EAAE,OAAO,EAAE,KAAK,EAC3D,IAAI,EAAE,CAAC,OAAO,EAAE,iBAAiB,CAAC,KAAK,EAAE,KAAK,EAAE,KAAK,CAAC,KAAK,SAAS,CAAC,OAAO,CAAC,GAC5E,OAAO,CAAC,IAAI,CAAC,CAsDf;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+CG;AACH,wBAAgB,SAAS,CAAC,KAAK,EAAE,KAAK,EAAE,OAAO,EAAE,KAAK,EACpD,GAAG,EAAE,MAAM,GAAG,GAAG,EACjB,OAAO,CAAC,EAAE,aAAa,GAAG;IAAE,IAAI,CAAC,EAAE,KAAK,CAAA;CAAE,GACzC,SAAS,CAAC,cAAc,CAAC,KAAK,EAAE,KAAK,EAAE,OAAO,CAAC,CAAC,CAgElD"}

package/script/worker.js

@@ -0,0 +1,241 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.workerMain = workerMain;
+exports.useWorker = useWorker;
+const mod_js_1 = require("./deps/jsr.io/@std/assert/1.0.12/mod.js");
+const effection_1 = require("effection");
+/**
+ * Entrypoint used in the worker that estaliblishes communication
+ * with the main thread. It can be used to return a value,
+ * respond to messages or both.
+ *
+ * @example Returning a value
+ * ```ts
+ * import { workerMain } from "../worker.ts";
+ *
+ * await workerMain(function* ({ data }) {
+ *  return data;
+ * });
+ * ```
+ *
+ * @example Responding to messages
+ * ```ts
+ * import { workerMain } from "../worker.ts";
+ *
+ * await workerMain(function* ({ messages }) {
+ *  yield* messages.forEach(function* (message) {
+ *    return message;
+ *  });
+ * });
+ * ```
+ *
+ * @example Responding to messages and return a value
+ * ```ts
+ * import { workerMain } from "../worker.ts";
+ *
+ * await workerMain<number, number, number, number>(
+ *   function* ({ messages, data: initial }) {
+ *     let counter = initial;
+ *
+ *     yield* messages.forEach(function* (message) {
+ *       counter += message;
+ *       return counter; // returns a value after each message
+ *     });
+ *
+ *     return counter; // returns the final value
+ *   },
+ * );
+ * ```
+ *
+ * @template TSend - value main thread will send to the worker
+ * @template TRecv - value main thread will receive from the worker
+ * @template TReturn - worker operation return value
+ * @template TData - data passed from the main thread to the worker during initialization
+ * @param {(options: WorkerMainOptions<TSend, TRecv, TData>) => Operation<TReturn>} body
+ * @returns {Promise<void>}
+ */
+async function workerMain(body) {
+    await (0, effection_1.main)(function* () {
+        let sent = (0, effection_1.createSignal)();
+        let controls = yield* (0, effection_1.on)(self, "message");
+        let outcome = (0, effection_1.withResolvers)();
+        self.postMessage({ type: "open" });
+        let result = yield* (0, effection_1.scoped)(function* () {
+            yield* (0, effection_1.spawn)(function* () {
+                let next = yield* controls.next();
+                while (true) {
+                    let control = next.value.data;
+                    if (control.type === "init") {
+                        yield* (0, effection_1.spawn)(function* () {
+                            try {
+                                let value = yield* body({
+                                    data: control.data,
+                                    messages: {
+                                        *forEach(fn) {
+                                            for (let { value, response } of yield* (0, effection_1.each)(sent)) {
+                                                yield* (0, effection_1.spawn)(function* () {
+                                                    try {
+                                                        let result = yield* fn(value);
+                                                        response.postMessage((0, effection_1.Ok)(result));
+                                                    }
+                                                    catch (error) {
+                                                        response.postMessage((0, effection_1.Err)(error));
+                                                    }
+                                                });
+                                                yield* effection_1.each.next();
+                                            }
+                                        },
+                                    },
+                                });
+                                outcome.resolve((0, effection_1.Ok)(value));
+                            }
+                            catch (error) {
+                                outcome.resolve((0, effection_1.Err)(error));
+                            }
+                        });
+                    }
+                    else if (control.type === "send") {
+                        let { value, response } = control;
+                        sent.send({ value, response });
+                    }
+                    else if (control.type === "close") {
+                        outcome.resolve((0, effection_1.Err)(new Error(`worker terminated`)));
+                    }
+                    next = yield* controls.next();
+                }
+            });
+            return yield* outcome.operation;
+        });
+        self.postMessage({ type: "close", result });
+    });
+}
+/**
+ * Use on the main thread to create and exeecute a well behaved web worker.
+ *
+ * @example Compute a single value
+ * ```ts
+ * import { run } from "effection";
+ * import { useWorker } from "@effectionx/worker"
+ *
+ * await run(function*() {
+ *    const worker = yield* useWorker("script.ts", { type: "module" });
+ *
+ *    try {
+ *      const result = yield* worker;
+ *    } catch (e) {
+ *      console.error(e);
+ *    }
+ * });
+ * ```
+ *
+ * @example Compute multipe values
+ * ```ts
+ * import { run } from "effection";
+ * import { useWorker } from "@effectionx/worker"
+ *
+ * await run(function*() {
+ *    const worker = yield* useWorker("script.ts", { type: "module" });
+ *
+ *    try {
+ *      const result1 = yield* worker.send("Tom");
+ *      const result2 = yield* worker.send("Dick");
+ *      const result2 = yield* worker.send("Harry");
+ *
+ *      // get the last result
+ *      const finalResult = yield* worker;
+ *    } catch (e) {
+ *      console.error(e);
+ *    }
+ * });
+ * ```
+ *
+ * @param url URL or string of script
+ * @param options WorkerOptions
+ * @template TSend - value main thread will send to the worker
+ * @template TRecv - value main thread will receive from the worker
+ * @template TReturn - worker operation return value
+ * @template TData - data passed from the main thread to the worker during initialization
+ * @returns {Operation<WorkerResource<TSend, TRecv>>}
+ */
+function useWorker(url, options) {
+    return (0, effection_1.resource)(function* (provide) {
+        let outcome = (0, effection_1.withResolvers)();
+        let worker = new Worker(url, options);
+        let subscription = yield* (0, effection_1.on)(worker, "message");
+        let onclose = (event) => {
+            if (event.data.type === "close") {
+                let { result } = event.data;
+                if (result.ok) {
+                    outcome.resolve(result.value);
+                }
+                else {
+                    outcome.reject(result.error);
+                }
+            }
+        };
+        worker.addEventListener("message", onclose);
+        let first = yield* subscription.next();
+        (0, mod_js_1.assert)(first.value.data.type === "open", `expected first message to arrive from worker to be of type "open", but was: ${first.value.data.type}`);
+        yield* (0, effection_1.spawn)(function* () {
+            let event = yield* (0, effection_1.once)(worker, "error");
+            event.preventDefault();
+            throw event.error;
+        });
+        try {
+            worker.postMessage({
+                type: "init",
+                data: options?.data,
+            });
+            yield* provide({
+                *send(value) {
+                    let channel = yield* useMessageChannel();
+                    worker.postMessage({
+                        type: "send",
+                        value,
+                        response: channel.port2,
+                    }, [channel.port2]);
+                    channel.port1.start();
+                    let event = yield* (0, effection_1.once)(channel.port1, "message");
+                    let result = event.data;
+                    if (result.ok) {
+                        return result.value;
+                    }
+                    else {
+                        throw result.error;
+                    }
+                },
+                [Symbol.iterator]: outcome.operation[Symbol.iterator],
+            });
+        }
+        finally {
+            worker.postMessage({ type: "close" });
+            yield* settled(outcome.operation);
+            worker.removeEventListener("message", onclose);
+        }
+    });
+}
+function useMessageChannel() {
+    return (0, effection_1.resource)(function* (provide) {
+        let channel = new MessageChannel();
+        try {
+            yield* provide(channel);
+        }
+        finally {
+            channel.port1.close();
+            channel.port2.close();
+        }
+    });
+}
+function settled(operation) {
+    return {
+        *[Symbol.iterator]() {
+            try {
+                yield* operation;
+                return (0, effection_1.Ok)();
+            }
+            catch (error) {
+                return (0, effection_1.Err)(error);
+            }
+        },
+    };
+}