From d589a16d87a40a7576cbd733a28b2734bf293670 Mon Sep 17 00:00:00 2001
From: Krasilnikov Roman <x0kill@ya.ru>
Date: Fri, 7 Jun 2024 13:19:43 +0300
Subject: [PATCH 1/5] WIP: RPC

---
 src/lib/guards.ts                    |  3 +++
 src/lib/patcher.ts                   |  7 +++++
 src/lib/rpc.ts                       | 39 ++++++++++++++++++++++++++++
 src/lib/testing/js/js-test-runner.ts |  6 ++---
 4 files changed, 52 insertions(+), 3 deletions(-)
 create mode 100644 src/lib/guards.ts
 create mode 100644 src/lib/patcher.ts
 create mode 100644 src/lib/rpc.ts

diff --git a/src/lib/guards.ts b/src/lib/guards.ts
new file mode 100644
index 0000000..43788a8
--- /dev/null
+++ b/src/lib/guards.ts
@@ -0,0 +1,3 @@
+export function neverError(value: never, message: string) {
+  return new Error(`${message}: ${value}`);
+}
diff --git a/src/lib/patcher.ts b/src/lib/patcher.ts
new file mode 100644
index 0000000..12d1ef3
--- /dev/null
+++ b/src/lib/patcher.ts
@@ -0,0 +1,7 @@
+export function patch<T, K extends keyof T>(obj: T, key: K, value: T[K]) {
+  const originalValue = obj[key];
+  obj[key] = value;
+  return () => {
+    obj[key] = originalValue;
+  };
+}
diff --git a/src/lib/rpc.ts b/src/lib/rpc.ts
new file mode 100644
index 0000000..4f8d206
--- /dev/null
+++ b/src/lib/rpc.ts
@@ -0,0 +1,39 @@
+import { neverError } from './guards';
+
+export enum MessageType {
+  Request = "request",
+}
+
+export interface AbstractMessage<T extends MessageType> {
+  type: T;
+}
+
+export interface RequestMessage<T>
+  extends AbstractMessage<MessageType.Request> {
+  id: number;
+  payload: T;
+}
+
+export type Message<T> = RequestMessage<T>;
+
+export interface HandlerCall<H extends string, I> {
+  handler: H;
+  args: I;
+}
+
+export type HandlerCalls<H extends Record<string, (...args: any[]) => any>> = {
+  [K in keyof H & string]: HandlerCall<K, Parameters<H[K]>>;
+}[keyof H & string];
+
+export function defineServer<H extends Record<string, (...args: any[]) => any>>(
+  handlers: H
+) {
+  function handleMessage({ data }: MessageEvent<Message<HandlerCalls<H>>>) {
+    switch (data.type) {
+      case MessageType.Request:
+        return
+      default:
+        throw neverError(data.type, `Unknown message type`);
+    }
+  }
+}
diff --git a/src/lib/testing/js/js-test-runner.ts b/src/lib/testing/js/js-test-runner.ts
index 273a823..3da6bf7 100644
--- a/src/lib/testing/js/js-test-runner.ts
+++ b/src/lib/testing/js/js-test-runner.ts
@@ -1,4 +1,5 @@
 import { redirect, type Logger } from "@/lib/logger";
+import { patch } from "@/lib/patcher";
 
 import type { TestRunner } from "../model";
 
@@ -19,13 +20,12 @@ export abstract class JsTestRunner<M, I, O> implements TestRunner<I, O> {
 
   async run(input: I): Promise<O> {
     const transformedCode = this.transformCode(this.code);
-    const originalConsole = globalThis.console;
-    globalThis.console = this.patchedConsole
+    const recover = patch(globalThis, "console", this.patchedConsole);
     try {
       const m = await import(/* @vite-ignore */ transformedCode);
       return this.executeTest(m, input);
     } finally {
-      globalThis.console = originalConsole;
+      recover();
     }
   }
 

From ac2b837026e687c0263569f10c72f368e0fc0a2e Mon Sep 17 00:00:00 2001
From: Krasilnikov Roman <x0kill@ya.ru>
Date: Mon, 10 Jun 2024 01:26:18 +0300
Subject: [PATCH 2/5] WIP: Connection

---
 src/lib/actor/actor.ts             | 140 +++++++++++++++++++++++++++++
 src/lib/actor/connection.ts        |   4 +
 src/lib/actor/index.ts             |   2 +
 src/lib/actor/worker-connection.ts |  30 +++++++
 src/lib/context.ts                 |  41 +++++++++
 src/lib/result.ts                  |  27 ++++++
 src/lib/rpc.ts                     |  39 --------
 src/lib/type.ts                    |   3 +
 8 files changed, 247 insertions(+), 39 deletions(-)
 create mode 100644 src/lib/actor/actor.ts
 create mode 100644 src/lib/actor/connection.ts
 create mode 100644 src/lib/actor/index.ts
 create mode 100644 src/lib/actor/worker-connection.ts
 create mode 100644 src/lib/context.ts
 create mode 100644 src/lib/result.ts
 delete mode 100644 src/lib/rpc.ts
 create mode 100644 src/lib/type.ts

diff --git a/src/lib/actor/actor.ts b/src/lib/actor/actor.ts
new file mode 100644
index 0000000..1a1d84d
--- /dev/null
+++ b/src/lib/actor/actor.ts
@@ -0,0 +1,140 @@
+import type { AnyKey, Brand } from "@/lib/type";
+import { err, ok, type Result } from "@/lib/result";
+import { neverError } from "@/lib/guards";
+
+import type { Connection } from "./connection";
+
+export type ActorId = Brand<"ActorId">;
+
+export enum MessageType {
+  Event = "event",
+  Request = "request",
+  Response = "response",
+}
+
+export interface AbstractMessage<T extends MessageType> {
+  type: T;
+}
+
+export interface EventMessage<T extends AnyKey, P>
+  extends AbstractMessage<MessageType.Event> {
+  event: T;
+  payload: P;
+}
+
+export type RequestId = Brand<"RequestId">;
+
+export interface RequestMessage<T extends AnyKey, P>
+  extends AbstractMessage<MessageType.Request> {
+  id: RequestId;
+  request: T;
+  payload: P;
+}
+
+export interface ResponseMessage<R>
+  extends AbstractMessage<MessageType.Response> {
+  id: RequestId;
+  result: R;
+}
+
+export enum EventType {
+  Error = "error",
+  Cancel = "cancel",
+}
+
+export interface AbstractEventMessage<T extends EventType>
+  extends AbstractMessage<MessageType.Event> {
+  event: T;
+}
+
+export interface ErrorEventMessage<E>
+  extends AbstractEventMessage<EventType.Error> {
+  error: E;
+}
+
+export interface CancelRequestEventMessage
+  extends AbstractEventMessage<EventType.Cancel> {
+  id: RequestId;
+}
+
+export type Handlers = Record<string, (arg: any) => any>;
+
+type IncomingMessage<H extends Handlers> = {
+  [K in keyof H]:
+    | RequestMessage<K, Parameters<H[K]>[0]>
+    | EventMessage<K, Parameters<H[K]>[0]>;
+}[keyof H];
+
+type OutgoingMessage<H extends Handlers, E> =
+  | ResponseMessage<Result<ReturnType<H[keyof H]>, E>>
+  | ErrorEventMessage<E>;
+
+export interface ActorConfig<H extends Handlers, E> {
+  connection: Connection<IncomingMessage<H>, OutgoingMessage<H, E>>;
+  handlers: H;
+  caseError: (error: any) => E;
+}
+
+export class Actor<H extends Handlers, E> {
+  constructor(private readonly config: ActorConfig<H, E>) {}
+
+  start() {
+    const { connection } = this.config;
+    const handleMessage = this.handleMessage.bind(this);
+    connection.onMessage(handleMessage);
+    return () => {
+      connection.onMessage(handleMessage);
+    };
+  }
+
+  private async handleMessage(data: IncomingMessage<H>) {
+    switch (data.type) {
+      case MessageType.Request: {
+        const { connection } = this.config;
+        const result = await this.handleRequest(data);
+        connection.send(result);
+        return;
+      }
+      case MessageType.Event: {
+        await this.handleEvent(data);
+        return;
+      }
+      default:
+        throw neverError(data, "Unknown message type");
+    }
+  }
+
+  private async handleEvent<K extends keyof H>(
+    event: EventMessage<K, Parameters<H[K]>[0]>
+  ) {
+    try {
+      await this.config.handlers[event.event](event.payload);
+    } catch (error) {
+      this.config.connection.send({
+        type: MessageType.Event,
+        event: EventType.Error,
+        error: this.config.caseError(error),
+      });
+    }
+  }
+
+  private async handleRequest<K extends keyof H>(
+    request: RequestMessage<K, Parameters<H[K]>[0]>
+  ): Promise<ResponseMessage<Result<ReturnType<H[K]>, E>>> {
+    const { handlers, caseError } = this.config;
+    try {
+      const result = await handlers[request.request](request.payload);
+      return {
+        type: MessageType.Response,
+        id: request.id,
+        result: ok(result),
+      };
+    } catch (error) {
+      return {
+        type: MessageType.Response,
+        id: request.id,
+        result: err(caseError(error)),
+      };
+    }
+  }
+}
diff --git a/src/lib/actor/connection.ts b/src/lib/actor/connection.ts
new file mode 100644
index 0000000..3f56a1f
--- /dev/null
+++ b/src/lib/actor/connection.ts
@@ -0,0 +1,4 @@
+export interface Connection<Incoming, Outgoing> {
+  onMessage: (handler: (message: Incoming) => void) => () => void;
+  send: (message: Outgoing) => void;
+}
diff --git a/src/lib/actor/index.ts b/src/lib/actor/index.ts
new file mode 100644
index 0000000..bbfe941
--- /dev/null
+++ b/src/lib/actor/index.ts
@@ -0,0 +1,2 @@
+export * from './actor'
+export * from './worker-connection'
diff --git a/src/lib/actor/worker-connection.ts b/src/lib/actor/worker-connection.ts
new file mode 100644
index 0000000..588d873
--- /dev/null
+++ b/src/lib/actor/worker-connection.ts
@@ -0,0 +1,30 @@
+import type { Connection } from "./connection";
+
+export class WorkerConnection<I, O> implements Connection<I, O> {
+  private handlers = new Set<(message: I) => void>();
+
+  constructor(private readonly worker: Worker) {}
+
+  start() {
+    const onMsg = (e: MessageEvent) => {
+      for (const handler of this.handlers) {
+        handler(e.data);
+      }
+    };
+    this.worker.addEventListener("message", onMsg);
+    return () => {
+      this.worker.removeEventListener("message", onMsg);
+    };
+  }
+
+  send(message: O) {
+    this.worker.postMessage(message);
+  }
+
+  onMessage(handler: (message: I) => void) {
+    this.handlers.add(handler);
+    return () => {
+      this.handlers.delete(handler);
+    };
+  }
+}
diff --git a/src/lib/context.ts b/src/lib/context.ts
new file mode 100644
index 0000000..3d9390b
--- /dev/null
+++ b/src/lib/context.ts
@@ -0,0 +1,41 @@
+export interface Context {
+  signal: AbortSignal;
+  canceled: boolean;
+  cancel(): void;
+  onCancel(cb: () => void): () => void;
+}
+
+export function root(): Context {
+  const ctrl = new AbortController();
+  return {
+    get canceled() {
+      return ctrl.signal.aborted;
+    },
+    get signal() {
+      return ctrl.signal;
+    },
+    onCancel(cb) {
+      ctrl.signal.addEventListener("abort", cb);
+      return () => ctrl.signal.removeEventListener("abort", cb);
+    },
+    cancel() {
+      ctrl.abort();
+    },
+  };
+}
+
+export function withCancel(ctx: Context): Context {
+  if (ctx.canceled) {
+    return ctx;
+  }
+  const leaf = root();
+  const cancel = () => {
+    ctx.signal.removeEventListener("abort", cancel);
+    leaf.cancel();
+  };
+  ctx.signal.addEventListener("abort", cancel);
+  return {
+    ...leaf,
+    cancel,
+  };
+}
diff --git a/src/lib/result.ts b/src/lib/result.ts
new file mode 100644
index 0000000..8746f64
--- /dev/null
+++ b/src/lib/result.ts
@@ -0,0 +1,27 @@
+export interface Ok<T> {
+  ok: true
+  value: T
+}
+
+export interface Err<E> {
+  ok: false
+  error: E
+}
+
+export type Result<T, E> = Ok<T> | Err<E>
+
+export function isOk<T, E>(result: Result<T, E>): result is Ok<T> {
+  return result.ok
+}
+
+export function isErr<T, E>(result: Result<T, E>): result is Err<E> {
+  return !result.ok
+}
+
+export function ok<T>(value: T): Ok<T> {
+  return { ok: true, value }
+}
+
+export function err<E>(error: E): Err<E> {
+  return { ok: false, error }
+}
diff --git a/src/lib/rpc.ts b/src/lib/rpc.ts
deleted file mode 100644
index 4f8d206..0000000
--- a/src/lib/rpc.ts
+++ /dev/null
@@ -1,39 +0,0 @@
-import { neverError } from './guards';
-
-export enum MessageType {
-  Request = "request",
-}
-
-export interface AbstractMessage<T extends MessageType> {
-  type: T;
-}
-
-export interface RequestMessage<T>
-  extends AbstractMessage<MessageType.Request> {
-  id: number;
-  payload: T;
-}
-
-export type Message<T> = RequestMessage<T>;
-
-export interface HandlerCall<H extends string, I> {
-  handler: H;
-  args: I;
-}
-
-export type HandlerCalls<H extends Record<string, (...args: any[]) => any>> = {
-  [K in keyof H & string]: HandlerCall<K, Parameters<H[K]>>;
-}[keyof H & string];
-
-export function defineServer<H extends Record<string, (...args: any[]) => any>>(
-  handlers: H
-) {
-  function handleMessage({ data }: MessageEvent<Message<HandlerCalls<H>>>) {
-    switch (data.type) {
-      case MessageType.Request:
-        return
-      default:
-        throw neverError(data.type, `Unknown message type`);
-    }
-  }
-}
diff --git a/src/lib/type.ts b/src/lib/type.ts
new file mode 100644
index 0000000..d2b797a
--- /dev/null
+++ b/src/lib/type.ts
@@ -0,0 +1,3 @@
+export type Brand<Name extends string, Base = string> = Base & { __brand: Name }
+
+export type AnyKey = keyof any;

From 31f8bd8d05ff25aaff1ade6350009a7120009abf Mon Sep 17 00:00:00 2001
From: Krasilnikov Roman <x0kill@ya.ru>
Date: Mon, 10 Jun 2024 03:09:38 +0300
Subject: [PATCH 3/5] WIP: Testing actor

---
 src/adapters/testing-actor.ts      | 72 +++++++++++++++++++++++
 src/lib/actor/actor.ts             | 93 ++++++------------------------
 src/lib/actor/connection.ts        |  4 --
 src/lib/actor/model.ts             | 53 +++++++++++++++++
 src/lib/actor/remote.ts            | 33 +++++++++++
 src/lib/actor/worker-connection.ts |  2 +-
 6 files changed, 177 insertions(+), 80 deletions(-)
 create mode 100644 src/adapters/testing-actor.ts
 delete mode 100644 src/lib/actor/connection.ts
 create mode 100644 src/lib/actor/model.ts
 create mode 100644 src/lib/actor/remote.ts

diff --git a/src/adapters/testing-actor.ts b/src/adapters/testing-actor.ts
new file mode 100644
index 0000000..6242fa6
--- /dev/null
+++ b/src/adapters/testing-actor.ts
@@ -0,0 +1,72 @@
+import { Actor } from "@/lib/actor";
+import {
+  MessageType,
+  type Connection,
+  type EventMessage,
+  type IncomingMessage,
+  type OutgoingMessage,
+} from "@/lib/actor/model";
+import type { TestData, TestRunner, TestRunnerFactory } from "@/lib/testing";
+
+interface Handlers<I, O> {
+  [key: string]: any;
+  init: (code: string) => Promise<void>;
+  run: (data: TestData<I, O>) => Promise<O>;
+}
+
+export interface WriteEventMessage extends EventMessage<"write", string> {}
+export interface WritelnEventMessage extends EventMessage<"writeln", string> {}
+
+type LogEventMessage = WriteEventMessage | WritelnEventMessage;
+
+export class TestRunnerActor<I, O> extends Actor<Handlers<I, O>, string> {
+  private runner: TestRunner<I, O> | null = null;
+
+  constructor(
+    connection: Connection<
+      IncomingMessage<Handlers<I, O>>,
+      OutgoingMessage<Handlers<I, O>, string> | LogEventMessage
+    >,
+    factory: TestRunnerFactory<I, O>
+  ) {
+    super({
+      connection,
+      handlers: {
+        init: async (code) => {
+          this.runner = await factory({
+            code,
+            out: {
+              write(text) {
+                connection.send({
+                  type: MessageType.Event,
+                  event: "write",
+                  payload: text,
+                });
+              },
+              writeln(text) {
+                connection.send({
+                  type: MessageType.Event,
+                  event: "writeln",
+                  payload: text,
+                });
+              },
+            },
+          });
+        },
+        run: (data) => {
+          if (!this.runner) {
+            const err = new Error("Test runner not initialized");
+            connection.send({
+              type: MessageType.Event,
+              event: "error",
+              payload: err.message,
+            });
+            throw err;
+          }
+          return this.runner.run(data.input);
+        },
+      },
+      caseError: String,
+    });
+  }
+}
diff --git a/src/lib/actor/actor.ts b/src/lib/actor/actor.ts
index 1a1d84d..7b28d98 100644
--- a/src/lib/actor/actor.ts
+++ b/src/lib/actor/actor.ts
@@ -1,73 +1,16 @@
-import type { AnyKey, Brand } from "@/lib/type";
 import { err, ok, type Result } from "@/lib/result";
 import { neverError } from "@/lib/guards";
 
-import type { Connection } from "./connection";
-
-export type ActorId = Brand<"ActorId">;
-
-export enum MessageType {
-  Event = "event",
-  Request = "request",
-  Response = "response",
-}
-
-export interface AbstractMessage<T extends MessageType> {
-  type: T;
-}
-
-export interface EventMessage<T extends AnyKey, P>
-  extends AbstractMessage<MessageType.Event> {
-  event: T;
-  payload: P;
-}
-
-export type RequestId = Brand<"RequestId">;
-
-export interface RequestMessage<T extends AnyKey, P>
-  extends AbstractMessage<MessageType.Request> {
-  id: RequestId;
-  request: T;
-  payload: P;
-}
-
-export interface ResponseMessage<R>
-  extends AbstractMessage<MessageType.Response> {
-  id: RequestId;
-  result: R;
-}
-
-export enum EventType {
-  Error = "error",
-  Cancel = "cancel",
-}
-
-export interface AbstractEventMessage<T extends EventType>
-  extends AbstractMessage<MessageType.Event> {
-  event: T;
-}
-
-export interface ErrorEventMessage<E>
-  extends AbstractEventMessage<EventType.Error> {
-  error: E;
-}
-
-export interface CancelRequestEventMessage
-  extends AbstractEventMessage<EventType.Cancel> {
-  id: RequestId;
-}
-
-export type Handlers = Record<string, (arg: any) => any>;
-
-type IncomingMessage<H extends Handlers> = {
-  [K in keyof H]:
-    | RequestMessage<K, Parameters<H[K]>[0]>
-    | EventMessage<K, Parameters<H[K]>[0]>;
-}[keyof H];
-
-type OutgoingMessage<H extends Handlers, E> =
-  | ResponseMessage<Result<ReturnType<H[keyof H]>, E>>
-  | ErrorEventMessage<E>;
+import {
+  MessageType,
+  type Connection,
+  type EventMessage,
+  type Handlers,
+  type IncomingMessage,
+  type OutgoingMessage,
+  type RequestMessage,
+  type ResponseMessage,
+} from "./model";
 
 export interface ActorConfig<H extends Handlers, E> {
   connection: Connection<IncomingMessage<H>, OutgoingMessage<H, E>>;
@@ -76,7 +19,7 @@ export interface ActorConfig<H extends Handlers, E> {
 }
 
 export class Actor<H extends Handlers, E> {
-  constructor(private readonly config: ActorConfig<H, E>) {}
+  constructor(protected readonly config: ActorConfig<H, E>) {}
 
   start() {
     const { connection } = this.config;
@@ -87,20 +30,20 @@ export class Actor<H extends Handlers, E> {
     };
   }
 
-  private async handleMessage(data: IncomingMessage<H>) {
-    switch (data.type) {
+  private async handleMessage(msg: IncomingMessage<H>) {
+    switch (msg.type) {
       case MessageType.Request: {
         const { connection } = this.config;
-        const result = await this.handleRequest(data);
+        const result = await this.handleRequest(msg);
         connection.send(result);
         return;
       }
       case MessageType.Event: {
-        await this.handleEvent(data);
+        await this.handleEvent(msg);
         return;
       }
       default:
-        throw neverError(data, "Unknown message type");
+        throw neverError(msg, "Unknown message type");
     }
   }
 
@@ -112,8 +55,8 @@ export class Actor<H extends Handlers, E> {
     } catch (error) {
       this.config.connection.send({
         type: MessageType.Event,
-        event: EventType.Error,
-        error: this.config.caseError(error),
+        event: "error",
+        payload: this.config.caseError(error),
       });
     }
   }
diff --git a/src/lib/actor/connection.ts b/src/lib/actor/connection.ts
deleted file mode 100644
index 3f56a1f..0000000
--- a/src/lib/actor/connection.ts
+++ /dev/null
@@ -1,4 +0,0 @@
-export interface Connection<Incoming, Outgoing> {
-  onMessage: (handler: (message: Incoming) => void) => () => void;
-  send: (message: Outgoing) => void;
-}
diff --git a/src/lib/actor/model.ts b/src/lib/actor/model.ts
new file mode 100644
index 0000000..d2a6216
--- /dev/null
+++ b/src/lib/actor/model.ts
@@ -0,0 +1,53 @@
+import type { AnyKey, Brand } from "@/lib/type";
+import type { Result } from '@/lib/result';
+
+export enum MessageType {
+  Event = "event",
+  Request = "request",
+  Response = "response",
+}
+
+export interface AbstractMessage<T extends MessageType> {
+  type: T;
+}
+
+export interface EventMessage<T extends AnyKey, P>
+  extends AbstractMessage<MessageType.Event> {
+  event: T;
+  payload: P;
+}
+
+export type RequestId = Brand<"RequestId", number>;
+
+export interface RequestMessage<T extends AnyKey, P>
+  extends AbstractMessage<MessageType.Request> {
+  id: RequestId;
+  request: T;
+  payload: P;
+}
+
+export interface ResponseMessage<R>
+  extends AbstractMessage<MessageType.Response> {
+  id: RequestId;
+  result: R;
+}
+
+export interface Connection<Incoming, Outgoing> {
+  onMessage: (handler: (message: Incoming) => void) => () => void;
+  send: (message: Outgoing) => void;
+}
+
+export type Handlers = Record<string, (arg: any) => any>;
+
+export type IncomingMessage<H extends Handlers> = {
+  [K in keyof H]:
+    | RequestMessage<K, Parameters<H[K]>[0]>
+    | EventMessage<K, Parameters<H[K]>[0]>;
+}[keyof H];
+
+export interface ErrorEventMessage<E> extends EventMessage<"error", E> {}
+
+export type OutgoingMessage<H extends Handlers, E> =
+  | ResponseMessage<Result<ReturnType<H[keyof H]>, E>>
+  | ErrorEventMessage<E>;
+
diff --git a/src/lib/actor/remote.ts b/src/lib/actor/remote.ts
new file mode 100644
index 0000000..b2bbbc0
--- /dev/null
+++ b/src/lib/actor/remote.ts
@@ -0,0 +1,33 @@
+import {
+  MessageType,
+  type Connection,
+  type Handlers,
+  type IncomingMessage,
+  type RequestId,
+} from "./model";
+
+export function createRemote<H extends Handlers>(
+  connection: Connection<any, IncomingMessage<H>>
+) {
+  let lastId = 0;
+  // const
+  return new Proxy(
+    {},
+    {
+      get(_, prop) {
+        const request = prop as keyof H;
+        return (arg: Parameters<H[typeof request]>[0]) => {
+          const id = lastId++ as RequestId;
+          connection.send({
+            id: id,
+            request,
+            type: MessageType.Request,
+            payload: arg,
+          });
+        };
+      },
+    }
+  ) as {
+    [K in keyof H]: (arg: Parameters<H[K]>[0]) => Promise<ReturnType<H[K]>>;
+  };
+}
diff --git a/src/lib/actor/worker-connection.ts b/src/lib/actor/worker-connection.ts
index 588d873..335f315 100644
--- a/src/lib/actor/worker-connection.ts
+++ b/src/lib/actor/worker-connection.ts
@@ -1,4 +1,4 @@
-import type { Connection } from "./connection";
+import type { Connection } from "./model";
 
 export class WorkerConnection<I, O> implements Connection<I, O> {
   private handlers = new Set<(message: I) => void>();

From d48eb4c99c0e5f6cc68cd6f053768eefcf315aec Mon Sep 17 00:00:00 2001
From: Krasilnikov Roman <x0kill@ya.ru>
Date: Mon, 10 Jun 2024 12:40:08 +0300
Subject: [PATCH 4/5] Bump deps

---
 bun.lockb    | Bin 290668 -> 292895 bytes
 package.json |   6 +++---
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/bun.lockb b/bun.lockb
index 36ba9e201160fb6c4caabb76d4cb1abf599dbe7b..183f533c9f35be5b007c8b59b9f86438b3bbbac6 100755
GIT binary patch
delta 10646
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
TT1LEXHK8MJW`6#_>Z|_&8I9)u

delta 11226
zcmeHNX;>A<w(WtF&>9lKs2~!J#;fLD5JWg2%3z`q73TqBK*13O5pe(&fv5=1+M10~
zqdqfe)Tki_P>BqNXd(*40i5TcNF3sX<6HZ5w{mmylJEU_Ki-$~xmdMV?W)?ftGdqV
zw%6XYy?(}aiAx)ES*qLiqQS$8e@%!ot6|T^9<7|4{mYQg@=vBNDfo7Rd}_Rvz@HzN
z4sI$nFW3=3#;)(WEJ3Iv2+6l|1fec?e2nw(@VJq}_FbBO6}kd_HvF1^ckb5oEnwDD
z!T$g!px;-(j;eS4!AW&;1;G~9#5|3k?a_MQo-YVZp??nMQIiS;!2#T_P!OEJrQkQf
z{r73TdBJWB+X?K*e%}j1GjLn9XTL{i-yD1!%+bVxUloL;<mev+;dKZ@z;<A#{g#U4
z&vae|<^bk_Incxdg76wR1~w1W8SOZ*)q0@m;QFv*!S>*&pEUn`FzaD@y{0D#$wtM5
zgIb3{aNvQ$<0egv96wrU47&mBm%tq8V`Pd08izb$2FVHG6Gz9PoZ#j)9wf{^thJv3
z=0Jx>MNW={?gpC!`mI!JUk-Lmf^ect8#o)xDcS<&1=<FOHsBWEM&Nx%v{b%#R2#Ua
zL<{HwY+KZO9uou`Fu|V(x(}N-LM503IRoavQ&8U!90N|`l%FjZgtx&TK;RVJsnBNJ
z?}Q-KgMAJ*&)kUoDs&ETWOVe%NtjvoNo@%>fH_me@aKMtPH6#b2lIeE(7!GC@M&$Y
zbSM=(ErJay*x|t$E%J+C?&uhpXJlmL24>7NSfvIuY$PVAAq|@bw!fgYEd%q$>VSYa
zxLy~vpf`hg&=$}+i~f?v(U&y85HL?JFf+g5RJ%<7Hr7qm_Rg)<3C`A;@!d*ZSFJ-_
zGvh<|MW{3KIw~D^34$-YWi{W`tW1ODX|V#_%*rlU9brjoKCFANI=~Xu6j-ji1!0iZ
zuB}-*wp)Fe@2kAEM{}`K1KOHRVX(%kxxG7DqhPl9iXLXMrCL+qr-b7&?P<}tx2?MM
zk{XcUWeuY%s;pFThL`nsg5V89QUlCpB_39LSc;k-U{<!k>Sl3d>kce`!!otsi+QQJ
z0Y1t^l-`Gq8N%xztPcz?rFEVlbccl*qHY$fcVJ<LUCgE;Se|O`gpSs@PDVX<@+i=f
zB3sgs0qaHQF@=H<0Z(nH8?Z)b?cB_!p*UB()kGH`B?Bc6K^ycAtT3aEX(CRUF>0cl
zk8%PfZmsp@TO<fk&#f<E@lu%7fOpKwQ&{gBb*2;?AAKx6l%k}iIN!s|8m9|8S#j8=
zOt#p`bRVUTmXbTpq3)K33sC9`Uj$g<Wd$S5BD?;m%~gwg9;}X*QL(5>5v*QX6D0C=
z98JL%E2XVjnGTD)Lt0(T$`M%XDX1y#W~KQ-&5~8_Wj-wS6x4iYvr?+p!PCpjy0})F
zltft1*G(!bR;L~ERjdyQLO-;|%1rZOqYn&;I~KoGy$|~-_n`S`-Mg5@KsD#EpSW7B
zLCrxNWqN<uxD9btc2yI*_$VKs)DA7IEm>O&tB?95*hjI$iKb7!#H{p!#Y>3g@H9(z
z%hX+^zTyD2rqoZ&SG~*pq=!GN)5?66$wvgCw<V^OG_&aftdVMNsgE)c=N+$&HMdt*
z!U}xu^&6~r)ZB`W*2e^)Gh{&xa5bCezzR_l%Y2mj#|2@SreiO}!P0Y$%PI#JhiM7S
zbQjh@ZetpR^D&4^qN3&;^)t=H`PSP~qnyCtYGPX-B?2Wsv=!9=^t2upUusC_*JkA|
zEbbRO0f&YgPDy`@g{xkSRTGZ;Nu?*%UB`V*%}-gn>*}M7L#Yd#u$b?gl?$*2TP$97
zZycXJv<^JYrrB(9Fw)i2YKID6rRy2(vXoS$O-Y9pWN~Jz-dRED``lUyi+6xxxi+g{
zX&KAMzH>gO9VFOW-<p+Cusoi(+XzeZ6fxIpu=r@R90Q8~d97VtUL4aLSpJr);d_+4
z;PsL!cJ>m_tJ6;TD%~$=#}jrS_Wev)1K=U3Vo$Sj5>^LGubi_67qwpDiP$1wX-ken
z&a?*>mb|@>^z5SA;f$}c;F6Xt3>9ToF2eFhM^<WnnAz0gvgLBeu@Z+8FA=VAWOz5M
zPMVjS+4cdfcX@C@5E$R7ZqEPAymNM#U6K{dIQ)^olXad7X192*)L8+i==z7c&dkMB
z{HX{2NY|OU_%Z&-;5A_G?-QNZg7Ht-U?n7396pD|j+?+QfwzIV!FDhQ_O;I6==x4@
zBj^WpyI8M347P@T9Lxcq)9p$y_jgt2Yv4Mt?^q>i4IV?_4>NaQWzrg$!1yQB!5<E+
z9@qx#1ZKaMT=_fZfLrN$ZRYmQ(0QV+dcA8B3ivG}_<=b>f4zd4Q`$$@`|3I~`}G5J
zM+0@8ndcCq+qIbo9t!<s@F>0B;3T8K%pFF8?ZDG@M`rGr1Le;jF$a{a`^^S(22yo@
zX0D&BbDFL*Bd{c4kzTP_uc*x&&@$*8z(+cNtn(*e?szSjKg?YGRJUt02lP2~_WwfX
zjbI7m3t#FDYBLY`6?EpWEslcl4Y)4sy}F$b<_-(M{He{H^8LEb%*A5-;R%)KI<tiF
zg)$U)pksOkGe=ym+sr&rh0Z5*otcYg@rV7->-rxt*Iz_E_ro8)dKj6H&j$Z}2>g8r
z@Sf04hrbU2&IBI@|IZJBr>{NLPlK#2uZV40`d=#_vFN9hxmT`v4!ZYoMT17_tk{wE
zy#ohkSGpF?ZCY>XK=;m5+Z`$P^FBJZ!8->xtf_1D(VkX$o6f)O*VFczS4~b<gLdM&
zCUo?e*yG#Y;?cR}d|d1y22sLsaWKUn7j5V?3%#jLIfT~b5Ehn0=t~tWl(W#O0z!XE
zuYizN0il|Of#iJxg4YQMYfeBIOjlW`WFhDzgb-SJ5<<pF2v1lTLV>3sbUOuM>nRAK
zRKvmp7D7)$7)qN?L)ds4g3TES;S_QPLhu;~xhxDP<tzm2vk;=sLKsOoEM&9bbPmF3
ziaZBl%sB|fEJTvSc?kCBAtauMFpdteu%89z3lO3y;R1yC3lL7T5JPP)LTG&v!orIX
zVyS|KauzyWf)GdPmms8Ff>6!EWb(cY!Rs=FHJ2ewrK>DdvJi9yLISP40wLoHgeNRa
zr@&tzbo&Lu)?XkbQVk0aSO~3zkVKm*A#ALKU~?5h3WZ#S5PTIvE(^0rxdy@d8ieR;
z5av)03)w6<RY90bkyQ}JR6!_aA)OqqL$JRNA@Mqd`E-DV{VX_FLs&=&)ez#VA)IDm
zF}3*>LhD~4Ec_M1QmSB~oP|y|AgGjn147yj2-PgCAn%(Hylz5Ra}xs5RTe5)2)YGf
zC9S*#A>$T=CoHU@z}pbI-G;FBHiR`)!@>g=LVts>mNxwcVdHNQZ0<l<Pa$_81mA&>
z%fbdy?n1D>3nBV0gwH64g=`j_?m_s1BJV*Ma}Po>3!BK{J_P&w5EAc0*h~jl*w2FV
z0|;9w;Q@sB2M|uPu#MW(Kxkb9VPOq~9aO<WISZX0Ldc}_hY->pLa1h8CwV`D;PnW?
znnw__=qd}9ECfA<kV7jUL&$gx;Ry@7Dewt|ZciX=eF7nuYFK!{Lg-Tnduh{C2pgY5
zuz3a{pF*BN2z~}3mxaO=iZpnIwPdp*TIwNwzaj@#wuDrOFn^#(Q9>$22*nVB4)AXh
z{bRLvRsT;%<$XH0e|YKg2f@OKDJ};GM6~pAxi{b|m(s@Fd+(3mb3Wnvn53=!=db)R
zyQFO3!-sFJ^X;YvmOL3UDaPSv)z!IC)(lBH<(!rLs`Rc{`!7LRj^|%iRMK9uHvNEy
z2X(1$OUaKln{#+7fS+~ARm?1pHe9VtG0stOi?Y^xNGBzmaNJHdhTnAX8(HvEMeaCQ
zO>=8qd$hmHe`nzTJ_CfUc%{ym0_~dGa)8<tO8yj8D7Efn+=q-o9e?5T54;2VtwN-(
z@lTzDx;9qV*bJr8LaBa(`CN}rlwQSmlFO;4P|9o&r?*<5SK-mLFqQK6N%h|zs#h&S
z6%UF>=)!PlEH8zIfBd9c$g|3Nx=-pS;w<c2B-QV<N^keM-eoKJsL=R+_zPWYjWXY|
z@~!GdU2B8#Xj+dh#4)t9NNOc^%sO2p`H7-^meYP|iKOU9&c35`=$O=;%72tTaN)Zm
zzLPo$oB~b*e8)8vxrzt)?(Apa2yoOy5kE<uL7Y-f;g0~PjqkQU073zN7?K901M>jR
z-2z|{uozeZECrSUDzH53@=uakv^$5ke20ezSi&@nd)!1W#ZtQ@zHK}N90u-TrsKd-
zKr}EOhyh}Oi2yIgBw#Wy1(*uN1H2N$fN&rJ7y*2Xv9o||AP3k5><0D#xxii^&kFy6
zlaE3HPzdY;z6X8)_5%liOcD=C@0s|a4^hw|>7Taz+-Mq*2*dyrveFMptE5qd7`6!D
zX97Dp1Rx981?&NGfz80j0B?fTKsqoVNCfckROk=x0(1icf$l&M&<o(lK!>boUa2(g
zO@79-4p<MY0<Ix-XMuA7Kku4EEz6|ip8QyXA6aY!HUVpabpStIum|}0O9|XdfimD{
z;D{Bq`&kMzeSz|1TJf_q_#gbR;WOY3pc&8{XaT$hJcXMGzGg*sN2Gt4w!q#>osLLN
z6@Glw6#?y_kudRlbIuWImJ{!Fe(b{gdo(Zx=!L2G0XkC4qtbg${A^+a@R44HC!+iS
zo1csdew2Pxnl3t#>6nzK97Xr|Bv)Iud`rFp_5+1L9)Ksm!X9uJAR9;n24*!lF8SHk
z>5FntAWxvMN~u>;AC!Xt_T_`57q|%ATW2m0KzRnZKR6dodw_l@M}xWDc%9jY`!}@V
zC?`OxLVY;Oq2L0bE5Q8>67i_U1%<(=90XLs`7&?`$ODEz3kIrD=DPP$4$=L%T&ZiJ
zD1QL3pW$Pa!)od5&+Uf+LxIb}Xsr{jsDnTvAaXeaWd_>~!E?c>z%A6x0Y?L~fHKr2
zfoA~IfoZ@<pb_-C08feo89}yHQhlchFh>ELlo;@MU>v}w^JogFk{ny|fnE<S>jNWD
zz5-W1&^a28j3WrAlq#u_ts%3-0Y%ZKDyc=#AN9bk*^STo7AV^Rwf#6CduR!$p9sVP
zuCOC$;dQBz7(s5=v6bVfFUTn#m5!*K0-g*^0;cL^O9OKfhZFR>{(8Xf4kV(^2Fx>?
ziE`~c_l3@JehB@~`bgIMaD#tJtv+U>jGX&g7S6~EFA{%UjX=lvA1uq(ONR|vSO{(f
z@HgFjzyaDkN~x9{lfH$S0qg))0NVj>{uTJYfOWuHU=^?&SOP2tp6MSI<z>K9UFSZy
zp8Na=;5q`hekJfRa2)-A0$#%pF;}C&PTY_yjLwaY*4L{4{a~9>_ZhGOVE<2njR1eu
z8bR?_@t43Rfa@7sfi1vdeu%jZ1tWmp4}b_QGvT0i0^b0vah7<7nE(&`HDJuPHgmfy
zfc@Ez$KeGr7Ac1>D}M-lxI_WFVeitx_ID`f0_@WT=m_kEoevZMKLAC*_rN~D4`3hs
zXQ9AvLUe)6yuBI)e9BY#=M0X4jzijchEDdPj2n`h=$iH84QaM0x>E03QVPt{TT;u|
zCdO+l=MF~>b%|KNNfN`{TwGn;1mSiLEsK=jmY(F$cagHa_%AvhDf@`qss30wNKB>h
zv9i0kg;ub&lP->xyWk#d^EmlU>OM}k6YEpxIMis8^lT3u8YlM@>yTrVd{}hMs)~|B
zWN{*uCddvHHbL&CmE9d5=UM*qBU$QPv#t1@+Y1m-I|Ss4=kfGt0)}i%ZDVBzu`LB9
zfr4mwtnBU>mT&n1mz?u;w*RvEuZ=}3cdb<{?O^wG`U&J{ytd-qxYyWH+tz1a_<c^#
zViB(+1x>^t+bLzDoZ=W;puPJM*!ZUNsVNP2zi>|?r#RWY$!$2`zjBf@mizBJk{xUh
z2M=xBM+FoWC)+z3Z|Jmp<<Z3fPRAC%=)#NE#v!tPloKcKlu8R}!X#wKGO`1GHC1km
zCr!5|$)mNTInb9=<Y81cS#GZB?$m4&eDpl@qtGex)j#N^7Y0C8kWob$@v@zCsff13
z%gw~jl)_mYLgy1f(Ih5d@|INzqGUH?RSx6pdi^x4TMWfcN4AZZg96%ZZn1MugVmUm
zzDBEP?{wM0!+4v>X>$0&{FwW>FC2{biJZH<>t$at=;IePTGQHt(@U5jothzktIg8=
zkHU4JLrHRbF^U3bV)^o^Z?asUzMP4<S*GDmPiM;Q9gVk*hFl)B<l4YDSG-sSOaA`6
zXF1vES<j6FeUgmSTlR{BHjV>bXGvQPYL<es8~LOlXEUhohsf=GYWX1+=tc?En<d+O
z7;h8JJhU#M&Vaf-C2?jumv%1h_(mz!-mn=luH}>~Q(mrkQPYA#XQ8JKG<6nMsRwO_
z<!HP`bRoDZv~|6^{Us3>i%Wa__i+rJg@Z?m-k<l5p$o69Sd;m}!FY2iJ#4*O^{%=v
zzo^+p&a-8QCYE=mu)902@$+4<W7u2Bng@c!wfI{pJ)JGvQ%S09M+;`l){ajwOau6S
zvUK3q;n5YruZzB&aE{<G*+SdUnV3yG=A%#J^{ZtC1r-hY*kXFPQr*lh9!8&H3#v+$
z9VC4SsiuU6&BKLcypMI$Y(MW!hfqw^XsGq<X}qX)@*T$~ullx4kwh;oSm8g%)Q1!<
z;9hGE4mVHwWsdAFojFELQf2!l#yeblo88-TbFQB&#?nv4`^TscJoMS<vC`^Pxv>$j
zB_~REyu|Pd((&(;as1DWZh#|B^JHxjdWSey|5rI{V!Q)(_U3Z?^CN;UAz*9*Ua4~x
zbaO7!XS`(=u}wMo_LQhOmMP(k#Lp;8zHv-+O2f5nylwVPzhz%l#!QTaAGRg?St4xo
z2JT18v^VJfeF;7ArGYieOT+FqUQH7mCpu?F%;~Oog57PrycT<;UbS^2lUC#A;)UPg
zWRs3<qSJN?V5^9RfQ-~ihfmXz^xtRyFOy{~w!WkOWOenuW{jux+{nsPICh4<;!XHJ
zZ;TFfejXw<cB}DDU8P{RtM0F@enAGjab4njwFR}sb>LyVe7CV@-{znDzV9Q6eEs9H
z75-|Y|K*h+?xUYD#PeCKqGvF1Zg7OyVLZORfoaqNxde~n`!0lJA$PGo%~^==zOoD2
zSK9*5tw$HEob|nB!??M$!<`kqxd`r?$p_>Zh<luR*uX0b!*47Zyr>9%?X|5JLNV+Y
zP3ep9;~;?!FOt*iw4ST|IvJCe6|q=O73*ZAX~L25S+|$S{hCp~Ou1Rsh#m6b*YPW*
beUZFnc2@l!Rx$rFxw=dmJ&j^tl`{St1Aw5F

diff --git a/package.json b/package.json
index 119712d..fad4ec2 100644
--- a/package.json
+++ b/package.json
@@ -17,17 +17,17 @@
     "@php-wasm/web": "^0.7.20",
     "@xterm/addon-fit": "^0.10.0",
     "@xterm/xterm": "^5.5.0",
-    "astro": "^4.10.0",
+    "astro": "^4.10.1",
     "astro-icon": "^1.1.0",
     "fast-deep-equal": "^3.1.3",
     "monaco-editor": "^0.49.0",
     "monaco-vim": "^0.4.1",
-    "pyodide": "^0.26.0",
+    "pyodide": "^0.26.1",
     "tailwindcss": "^3.4.4",
     "typescript": "^5.4.5"
   },
   "devDependencies": {
-    "@iconify-json/lucide": "^1.1.190",
+    "@iconify-json/lucide": "^1.1.191",
     "@iconify/svelte": "^4.0.2",
     "@tailwindcss/typography": "^0.5.13",
     "@types/color": "^3.0.6",

From a2fda7cfe8a12f174718ab323f07dc51d42925e6 Mon Sep 17 00:00:00 2001
From: Krasilnikov Roman <x0kill@ya.ru>
Date: Wed, 12 Jun 2024 13:11:42 +0300
Subject: [PATCH 5/5] Move tests execution to the workers

---
 src/adapters/testing-actor.ts                 | 147 ++++++++++++------
 .../design-patterns/factory/editor.svelte     |  43 ++---
 .../design-patterns/factory/js/index.ts       |   3 +
 .../factory/js/test-runners.ts                |  29 ----
 .../design-patterns/factory/js/worker.ts      |  22 +++
 .../design-patterns/factory/php/index.ts      |   3 +
 .../php/{test-runners.ts => worker.ts}        |   7 +-
 .../design-patterns/factory/python/index.ts   |   3 +
 .../python/{test-runners.ts => worker.ts}     |   9 +-
 .../factory/{js => ts}/code.ts                |   0
 .../design-patterns/factory/ts/index.ts       |   3 +
 .../design-patterns/factory/ts/worker.ts      |  22 +++
 src/lib/actor/actor.ts                        |  28 ++--
 src/lib/actor/index.ts                        |   2 +
 src/lib/actor/model.ts                        |   3 +-
 src/lib/actor/remote.ts                       |  73 ++++++++-
 src/lib/actor/worker-connection.ts            |  10 +-
 17 files changed, 282 insertions(+), 125 deletions(-)
 create mode 100644 src/content/design-patterns/factory/js/index.ts
 delete mode 100644 src/content/design-patterns/factory/js/test-runners.ts
 create mode 100644 src/content/design-patterns/factory/js/worker.ts
 create mode 100644 src/content/design-patterns/factory/php/index.ts
 rename src/content/design-patterns/factory/php/{test-runners.ts => worker.ts} (82%)
 create mode 100644 src/content/design-patterns/factory/python/index.ts
 rename src/content/design-patterns/factory/python/{test-runners.ts => worker.ts} (57%)
 rename src/content/design-patterns/factory/{js => ts}/code.ts (100%)
 create mode 100644 src/content/design-patterns/factory/ts/index.ts
 create mode 100644 src/content/design-patterns/factory/ts/worker.ts

diff --git a/src/adapters/testing-actor.ts b/src/adapters/testing-actor.ts
index 6242fa6..c187968 100644
--- a/src/adapters/testing-actor.ts
+++ b/src/adapters/testing-actor.ts
@@ -1,72 +1,123 @@
-import { Actor } from "@/lib/actor";
 import {
+  Actor,
   MessageType,
+  WorkerConnection,
+  startRemote,
   type Connection,
   type EventMessage,
   type IncomingMessage,
   type OutgoingMessage,
-} from "@/lib/actor/model";
-import type { TestData, TestRunner, TestRunnerFactory } from "@/lib/testing";
+} from "@/lib/actor";
+import { createLogger } from "@/lib/logger";
+import type { TestRunner, TestRunnerFactory } from "@/lib/testing";
 
 interface Handlers<I, O> {
   [key: string]: any;
   init: (code: string) => Promise<void>;
-  run: (data: TestData<I, O>) => Promise<O>;
+  run: (data: I) => Promise<O>;
 }
 
-export interface WriteEventMessage extends EventMessage<"write", string> {}
-export interface WritelnEventMessage extends EventMessage<"writeln", string> {}
+type Incoming<I, O> = IncomingMessage<Handlers<I, O>>;
 
-type LogEventMessage = WriteEventMessage | WritelnEventMessage;
+interface WriteEventMessage extends EventMessage<"write", string> {}
+interface WritelnEventMessage extends EventMessage<"writeln", string> {}
 
-export class TestRunnerActor<I, O> extends Actor<Handlers<I, O>, string> {
+type TestingActorEvent = WriteEventMessage | WritelnEventMessage;
+
+type Outgoing<I, O> = OutgoingMessage<Handlers<I, O>, string> | TestingActorEvent;
+
+class TestRunnerActor<I, O> extends Actor<Handlers<I, O>, string> {
   private runner: TestRunner<I, O> | null = null;
 
   constructor(
-    connection: Connection<
-      IncomingMessage<Handlers<I, O>>,
-      OutgoingMessage<Handlers<I, O>, string> | LogEventMessage
-    >,
+    connection: Connection<Incoming<I, O>, Outgoing<I, O>>,
     factory: TestRunnerFactory<I, O>
   ) {
-    super({
-      connection,
-      handlers: {
-        init: async (code) => {
-          this.runner = await factory({
-            code,
-            out: {
-              write(text) {
-                connection.send({
-                  type: MessageType.Event,
-                  event: "write",
-                  payload: text,
-                });
-              },
-              writeln(text) {
-                connection.send({
-                  type: MessageType.Event,
-                  event: "writeln",
-                  payload: text,
-                });
-              },
+    const handlers: Handlers<I, O> = {
+      init: async (code) => {
+        this.runner = await factory({
+          code,
+          out: {
+            write(text) {
+              connection.send({
+                type: MessageType.Event,
+                event: "write",
+                payload: text,
+              });
+            },
+            writeln(text) {
+              connection.send({
+                type: MessageType.Event,
+                event: "writeln",
+                payload: text,
+              });
             },
+          },
+        });
+      },
+      run: (input) => {
+        if (!this.runner) {
+          const err = new Error("Test runner not initialized");
+          connection.send({
+            type: MessageType.Event,
+            event: "error",
+            payload: err.message,
           });
-        },
-        run: (data) => {
-          if (!this.runner) {
-            const err = new Error("Test runner not initialized");
-            connection.send({
-              type: MessageType.Event,
-              event: "error",
-              payload: err.message,
-            });
-            throw err;
-          }
-          return this.runner.run(data.input);
-        },
+          throw err;
+        }
+        return this.runner.run(input);
       },
-      caseError: String,
-    });
+    };
+    super(connection, handlers, String);
   }
 }
+
+export function startTestRunnerActor<I, O>(factory: TestRunnerFactory<I, O>) {
+  const connection = new WorkerConnection<Incoming<I, O>, Outgoing<I, O>>(
+    self as unknown as Worker
+  );
+  const actor = new TestRunnerActor(connection, factory);
+  const stopConnection = connection.start();
+  const stopActor = actor.start();
+  return () => {
+    stopActor();
+    stopConnection();
+  };
+}
+
+interface WorkerConstructor {
+  new (): Worker;
+}
+
+export function makeRemoteTestRunnerFactory<I, O>(
+  Worker: WorkerConstructor
+): TestRunnerFactory<I, O> {
+  return async ({ code, out }) => {
+    const worker = new Worker();
+    const connection = new WorkerConnection<Outgoing<I, O>, Incoming<I, O>>(
+      worker
+    );
+    const stopConnection = connection.start();
+    const log = createLogger(out);
+    const remote = startRemote<Handlers<I, O>, string, TestingActorEvent>(
+      log,
+      connection,
+      {
+        error: (err) => log.error(err),
+        write: (text) => out.write(text),
+        writeln: (text) => out.writeln(text),
+      }
+    );
+    await remote.init(code);
+    return {
+      async run(input) {
+        return remote.run(input);
+      },
+      [Symbol.dispose]() {
+        remote[Symbol.dispose]();
+        stopConnection();
+        worker.terminate();
+      },
+    };
+  };
+}
diff --git a/src/content/design-patterns/factory/editor.svelte b/src/content/design-patterns/factory/editor.svelte
index d4cc810..79b62de 100644
--- a/src/content/design-patterns/factory/editor.svelte
+++ b/src/content/design-patterns/factory/editor.svelte
@@ -1,31 +1,32 @@
 <script lang="ts">
-  import { Language, type TestRunnerFactory } from '@/lib/testing';
+  import { Language, type TestRunnerFactory } from "@/lib/testing";
+  import { makeRemoteTestRunnerFactory } from "@/adapters/testing-actor";
 
-  import Editor from '@/components/editor/editor.svelte';
+  import Editor from "@/components/editor/editor.svelte";
 
-  import { testsData, type Input, type Output } from './tests-data'
-  import { testRunnerFactory as phpTestRunnerFactory } from './php/test-runners'
-  import { jsTestRunnerFactory, tsTestRunnerFactory } from './js/test-runners'
-  import { testRunnerFactory as pyTestRunnerFactory } from './python/test-runners'
+  import { testsData, type Input, type Output } from "./tests-data";
 
-  import phpInitialValue from './php/code.php?raw'
-  import tsInitialValue from './js/code.ts?raw'
-  import jsInitialValue from './js/code.js?raw'
-  import pyInitialValue from './python/code.py?raw'
+  import { jsCode, JsWorker } from "./js";
+  import { tsCode, TsWorker } from "./ts";
+  import { phpCode, PhpWorker } from "./php";
+  import { pyCode, PyWorker } from "./python";
 
   const INITIAL_VALUES: Record<Language, string> = {
-    [Language.PHP]: phpInitialValue,
-    [Language.TypeScript]: tsInitialValue,
-    [Language.JavaScript]: jsInitialValue,
-    [Language.Python]: pyInitialValue,
-  }
+    [Language.PHP]: phpCode,
+    [Language.TypeScript]: tsCode,
+    [Language.JavaScript]: jsCode,
+    [Language.Python]: pyCode,
+  };
 
-  const TEST_RUNNER_FACTORIES: Record<Language, TestRunnerFactory<Input, Output>> = {
-    [Language.PHP]: phpTestRunnerFactory,
-    [Language.TypeScript]: tsTestRunnerFactory,
-    [Language.JavaScript]: jsTestRunnerFactory,
-    [Language.Python]: pyTestRunnerFactory,
-  }
+  const TEST_RUNNER_FACTORIES: Record<
+    Language,
+    TestRunnerFactory<Input, Output>
+  > = {
+    [Language.PHP]: makeRemoteTestRunnerFactory(PhpWorker),
+    [Language.TypeScript]: makeRemoteTestRunnerFactory(TsWorker),
+    [Language.JavaScript]: makeRemoteTestRunnerFactory(JsWorker),
+    [Language.Python]: makeRemoteTestRunnerFactory(PyWorker),
+  };
 </script>
 
 <Editor
diff --git a/src/content/design-patterns/factory/js/index.ts b/src/content/design-patterns/factory/js/index.ts
new file mode 100644
index 0000000..b3aea3d
--- /dev/null
+++ b/src/content/design-patterns/factory/js/index.ts
@@ -0,0 +1,3 @@
+export { default as jsCode } from "./code.js?raw";
+
+export { default as JsWorker } from './worker?worker'
diff --git a/src/content/design-patterns/factory/js/test-runners.ts b/src/content/design-patterns/factory/js/test-runners.ts
deleted file mode 100644
index 4bec594..0000000
--- a/src/content/design-patterns/factory/js/test-runners.ts
+++ /dev/null
@@ -1,29 +0,0 @@
-import { createLogger } from '@/lib/logger';
-import type { TestRunnerConfig } from '@/lib/testing';
-import { TsTestRunner, JsTestRunner } from "@/lib/testing/js";
-
-import { type Input, type Output } from "../tests-data";
-import type { PaymentSystemType } from '../reference';
-
-interface TestingModule {
-  payment(type: PaymentSystemType, base: number, amount: number): number;
-}
-
-
-class SimpleJsTestRunner extends JsTestRunner<TestingModule, Input, Output> {
-  async executeTest(m: TestingModule, input: Input): Promise<Output> {
-    return m.payment(input.paymentSystem, input.base, input.amount);
-  }
-}
-
-export const jsTestRunnerFactory = async ({ code, out }: TestRunnerConfig) =>
-  new SimpleJsTestRunner(createLogger(out), code);
-
-class SimpleTsTestRunner extends TsTestRunner<TestingModule, Input, Output> {
-  async executeTest(m: TestingModule, input: Input): Promise<Output> {
-    return m.payment(input.paymentSystem, input.base, input.amount);
-  }
-}
-
-export const tsTestRunnerFactory = async ({ code, out }: TestRunnerConfig) =>
-  new SimpleTsTestRunner(createLogger(out), code);
diff --git a/src/content/design-patterns/factory/js/worker.ts b/src/content/design-patterns/factory/js/worker.ts
new file mode 100644
index 0000000..a877eb3
--- /dev/null
+++ b/src/content/design-patterns/factory/js/worker.ts
@@ -0,0 +1,22 @@
+import { createLogger } from "@/lib/logger";
+import type { TestRunnerConfig } from "@/lib/testing";
+import { JsTestRunner } from "@/lib/testing/js";
+import { startTestRunnerActor } from "@/adapters/testing-actor";
+
+import { type Input, type Output } from "../tests-data";
+import type { PaymentSystemType } from "../reference";
+
+interface TestingModule {
+  payment(type: PaymentSystemType, base: number, amount: number): number;
+}
+
+class SimpleJsTestRunner extends JsTestRunner<TestingModule, Input, Output> {
+  async executeTest(m: TestingModule, input: Input): Promise<Output> {
+    return m.payment(input.paymentSystem, input.base, input.amount);
+  }
+}
+
+startTestRunnerActor(
+  async ({ code, out }: TestRunnerConfig) =>
+    new SimpleJsTestRunner(createLogger(out), code)
+);
diff --git a/src/content/design-patterns/factory/php/index.ts b/src/content/design-patterns/factory/php/index.ts
new file mode 100644
index 0000000..729afca
--- /dev/null
+++ b/src/content/design-patterns/factory/php/index.ts
@@ -0,0 +1,3 @@
+export { default as phpCode } from './code.php?raw'
+
+export { default as PhpWorker } from './worker?worker'
diff --git a/src/content/design-patterns/factory/php/test-runners.ts b/src/content/design-patterns/factory/php/worker.ts
similarity index 82%
rename from src/content/design-patterns/factory/php/test-runners.ts
rename to src/content/design-patterns/factory/php/worker.ts
index f0365b6..c6ca3f5 100644
--- a/src/content/design-patterns/factory/php/test-runners.ts
+++ b/src/content/design-patterns/factory/php/worker.ts
@@ -4,6 +4,7 @@ import {
   PHPTestRunner,
   phpRuntimeFactory,
 } from "@/lib/testing/php";
+import { startTestRunnerActor } from "@/adapters/testing-actor";
 
 import { type Input, type Output } from "../tests-data";
 import { PaymentSystemType } from "../reference";
@@ -27,5 +28,7 @@ class SimpleTestRunner extends PHPTestRunner<Input, Output> {
   }
 }
 
-export const testRunnerFactory = async ({ code, out }: TestRunnerConfig) =>
-  new SimpleTestRunner(out, new FailSafePHP(phpRuntimeFactory), code);
+startTestRunnerActor(
+  async ({ code, out }: TestRunnerConfig) =>
+    new SimpleTestRunner(out, new FailSafePHP(phpRuntimeFactory), code)
+);
diff --git a/src/content/design-patterns/factory/python/index.ts b/src/content/design-patterns/factory/python/index.ts
new file mode 100644
index 0000000..40cbc3e
--- /dev/null
+++ b/src/content/design-patterns/factory/python/index.ts
@@ -0,0 +1,3 @@
+export { default as pyCode } from "./code.py?raw"
+
+export { default as PyWorker } from "./worker?worker"
diff --git a/src/content/design-patterns/factory/python/test-runners.ts b/src/content/design-patterns/factory/python/worker.ts
similarity index 57%
rename from src/content/design-patterns/factory/python/test-runners.ts
rename to src/content/design-patterns/factory/python/worker.ts
index 2760d5e..6c2f146 100644
--- a/src/content/design-patterns/factory/python/test-runners.ts
+++ b/src/content/design-patterns/factory/python/worker.ts
@@ -1,5 +1,6 @@
-import type { TestRunnerConfig } from '@/lib/testing';
+import type { TestRunnerConfig } from "@/lib/testing";
 import { PyTestRunner, pyRuntimeFactory } from "@/lib/testing/python";
+import { startTestRunnerActor } from "@/adapters/testing-actor";
 
 import { type Input, type Output } from "../tests-data";
 
@@ -9,5 +10,7 @@ class SimpleTestRunner extends PyTestRunner<Input, Output> {
   }
 }
 
-export const testRunnerFactory = async ({ code, out }: TestRunnerConfig) =>
-  new SimpleTestRunner(await pyRuntimeFactory(out), code);
+startTestRunnerActor(
+  async ({ code, out }: TestRunnerConfig) =>
+    new SimpleTestRunner(await pyRuntimeFactory(out), code)
+);
diff --git a/src/content/design-patterns/factory/js/code.ts b/src/content/design-patterns/factory/ts/code.ts
similarity index 100%
rename from src/content/design-patterns/factory/js/code.ts
rename to src/content/design-patterns/factory/ts/code.ts
diff --git a/src/content/design-patterns/factory/ts/index.ts b/src/content/design-patterns/factory/ts/index.ts
new file mode 100644
index 0000000..ea37eb2
--- /dev/null
+++ b/src/content/design-patterns/factory/ts/index.ts
@@ -0,0 +1,3 @@
+export { default as tsCode } from './code.ts?raw'
+
+export { default as TsWorker } from './worker?worker'
diff --git a/src/content/design-patterns/factory/ts/worker.ts b/src/content/design-patterns/factory/ts/worker.ts
new file mode 100644
index 0000000..78fddb8
--- /dev/null
+++ b/src/content/design-patterns/factory/ts/worker.ts
@@ -0,0 +1,22 @@
+import { createLogger } from "@/lib/logger";
+import type { TestRunnerConfig } from "@/lib/testing";
+import { TsTestRunner } from "@/lib/testing/js";
+import { startTestRunnerActor } from "@/adapters/testing-actor";
+
+import { type Input, type Output } from "../tests-data";
+import type { PaymentSystemType } from "../reference";
+
+interface TestingModule {
+  payment(type: PaymentSystemType, base: number, amount: number): number;
+}
+
+class SimpleTsTestRunner extends TsTestRunner<TestingModule, Input, Output> {
+  async executeTest(m: TestingModule, input: Input): Promise<Output> {
+    return m.payment(input.paymentSystem, input.base, input.amount);
+  }
+}
+
+startTestRunnerActor(
+  async ({ code, out }: TestRunnerConfig) =>
+    new SimpleTsTestRunner(createLogger(out), code)
+);
diff --git a/src/lib/actor/actor.ts b/src/lib/actor/actor.ts
index 7b28d98..e893d4b 100644
--- a/src/lib/actor/actor.ts
+++ b/src/lib/actor/actor.ts
@@ -19,23 +19,28 @@ export interface ActorConfig<H extends Handlers, E> {
 }
 
 export class Actor<H extends Handlers, E> {
-  constructor(protected readonly config: ActorConfig<H, E>) {}
+  constructor(
+    protected readonly connection: Connection<
+      IncomingMessage<H>,
+      OutgoingMessage<H, E>
+    >,
+    protected readonly handlers: H,
+    protected readonly caseError: (error: any) => E
+  ) {}
 
   start() {
-    const { connection } = this.config;
     const handleMessage = this.handleMessage.bind(this);
-    connection.onMessage(handleMessage);
+    this.connection.onMessage(handleMessage);
     return () => {
-      connection.onMessage(handleMessage);
+      this.connection.onMessage(handleMessage);
     };
   }
 
   private async handleMessage(msg: IncomingMessage<H>) {
     switch (msg.type) {
       case MessageType.Request: {
-        const { connection } = this.config;
         const result = await this.handleRequest(msg);
-        connection.send(result);
+        this.connection.send(result);
         return;
       }
       case MessageType.Event: {
@@ -51,12 +56,12 @@ export class Actor<H extends Handlers, E> {
     event: EventMessage<K, Parameters<H[K]>[0]>
   ) {
     try {
-      await this.config.handlers[event.event](event.payload);
+      await this.handlers[event.event](event.payload);
     } catch (error) {
-      this.config.connection.send({
+      this.connection.send({
         type: MessageType.Event,
         event: "error",
-        payload: this.config.caseError(error),
+        payload: this.caseError(error),
       });
     }
   }
@@ -64,9 +69,8 @@ export class Actor<H extends Handlers, E> {
   private async handleRequest<K extends keyof H>(
     request: RequestMessage<K, Parameters<H[K]>[0]>
   ): Promise<ResponseMessage<Result<ReturnType<H[K]>, E>>> {
-    const { handlers, caseError } = this.config;
     try {
-      const result = await handlers[request.request](request.payload);
+      const result = await this.handlers[request.request](request.payload);
       return {
         type: MessageType.Response,
         id: request.id,
@@ -76,7 +80,7 @@ export class Actor<H extends Handlers, E> {
       return {
         type: MessageType.Response,
         id: request.id,
-        result: err(caseError(error)),
+        result: err(this.caseError(error)),
       };
     }
   }
diff --git a/src/lib/actor/index.ts b/src/lib/actor/index.ts
index bbfe941..032b80c 100644
--- a/src/lib/actor/index.ts
+++ b/src/lib/actor/index.ts
@@ -1,2 +1,4 @@
+export * from './model'
 export * from './actor'
 export * from './worker-connection'
+export * from './remote'
diff --git a/src/lib/actor/model.ts b/src/lib/actor/model.ts
index d2a6216..35601e2 100644
--- a/src/lib/actor/model.ts
+++ b/src/lib/actor/model.ts
@@ -1,5 +1,5 @@
 import type { AnyKey, Brand } from "@/lib/type";
-import type { Result } from '@/lib/result';
+import type { Result } from "@/lib/result";
 
 export enum MessageType {
   Event = "event",
@@ -50,4 +50,3 @@ export interface ErrorEventMessage<E> extends EventMessage<"error", E> {}
 export type OutgoingMessage<H extends Handlers, E> =
   | ResponseMessage<Result<ReturnType<H[keyof H]>, E>>
   | ErrorEventMessage<E>;
-
diff --git a/src/lib/actor/remote.ts b/src/lib/actor/remote.ts
index b2bbbc0..a8580ab 100644
--- a/src/lib/actor/remote.ts
+++ b/src/lib/actor/remote.ts
@@ -1,33 +1,98 @@
+import type { Logger } from "@/lib/logger";
+import { neverError } from "@/lib/guards";
+import { isOk } from "@/lib/result";
+
 import {
   MessageType,
   type Connection,
+  type ErrorEventMessage,
+  type EventMessage,
   type Handlers,
   type IncomingMessage,
+  type OutgoingMessage,
   type RequestId,
 } from "./model";
 
-export function createRemote<H extends Handlers>(
-  connection: Connection<any, IncomingMessage<H>>
+interface DeferredPromise<T, E> {
+  resolve: (value: T) => void;
+  reject: (error: E) => void;
+}
+
+export function startRemote<
+  H extends Handlers,
+  E,
+  Event extends EventMessage<string, E>
+>(
+  log: Logger,
+  connection: Connection<OutgoingMessage<H, E> | Event, IncomingMessage<H>>,
+  eventHandlers: {
+    [K in Event["event"]]: (e: Extract<Event, EventMessage<K, any>>['payload']) => void;
+  } & {
+    [K in ErrorEventMessage<E>["event"]]: (e: ErrorEventMessage<E>['payload']) => void;
+  }
 ) {
   let lastId = 0;
-  // const
+  const promises = new Map<
+    RequestId,
+    DeferredPromise<ReturnType<H[keyof H]>, E>
+  >();
+  const unsubscribe = connection.onMessage((msg) => {
+    switch (msg.type) {
+      case MessageType.Response: {
+        const { id, result } = msg;
+        const deferred = promises.get(id);
+        if (!deferred) {
+          log.error(`Received response for unknown request ${id}`);
+          return;
+        }
+        promises.delete(id);
+        if (isOk(result)) {
+          deferred.resolve(result.value);
+        } else {
+          deferred.reject(result.error);
+        }
+        return;
+      }
+      case MessageType.Event: {
+        // @ts-expect-error ts problem
+        const handler = eventHandlers[msg.event];
+        if (!handler) {
+          log.error(`Received unknown event ${msg.event}`);
+          return;
+        }
+        handler(msg.payload);
+        return;
+      }
+      default:
+        throw neverError(msg, "Unknown message type");
+    }
+  });
   return new Proxy(
     {},
     {
       get(_, prop) {
+        if (prop === Symbol.dispose) {
+          return unsubscribe;
+        }
         const request = prop as keyof H;
         return (arg: Parameters<H[typeof request]>[0]) => {
           const id = lastId++ as RequestId;
+          const promise = new Promise<ReturnType<H[typeof request]>>(
+            (resolve, reject) => {
+              promises.set(id, { resolve, reject });
+            }
+          );
           connection.send({
             id: id,
             request,
             type: MessageType.Request,
             payload: arg,
           });
+          return promise;
         };
       },
     }
   ) as {
     [K in keyof H]: (arg: Parameters<H[K]>[0]) => Promise<ReturnType<H[K]>>;
-  };
+  } & Disposable;
 }
diff --git a/src/lib/actor/worker-connection.ts b/src/lib/actor/worker-connection.ts
index 335f315..49ee872 100644
--- a/src/lib/actor/worker-connection.ts
+++ b/src/lib/actor/worker-connection.ts
@@ -1,7 +1,9 @@
 import type { Connection } from "./model";
 
-export class WorkerConnection<I, O> implements Connection<I, O> {
-  private handlers = new Set<(message: I) => void>();
+export class WorkerConnection<Incoming, Outgoing>
+  implements Connection<Incoming, Outgoing>
+{
+  private handlers = new Set<(message: Incoming) => void>();
 
   constructor(private readonly worker: Worker) {}
 
@@ -17,11 +19,11 @@ export class WorkerConnection<I, O> implements Connection<I, O> {
     };
   }
 
-  send(message: O) {
+  send(message: Outgoing) {
     this.worker.postMessage(message);
   }
 
-  onMessage(handler: (message: I) => void) {
+  onMessage(handler: (message: Incoming) => void) {
     this.handlers.add(handler);
     return () => {
       this.handlers.delete(handler);