lopata 0.0.1

package/runtime/bindings/do-executor-worker.ts

@@ -0,0 +1,368 @@
+/**
+ * WorkerExecutor — runs each DO instance in a separate Bun Worker thread.
+ *
+ * Main thread side: spawns a Worker on first command, maintains a serial
+ * command queue, and bridges WebSocket events between main thread and worker.
+ */
+
+import { resolve, dirname } from "node:path";
+import type { DOExecutor, DOExecutorFactory, ExecutorConfig } from "./do-executor";
+import type { WsBridgeOutbound } from "./do-websocket-bridge";
+
+// --- Message protocol ---
+
+/** Commands sent from main thread to worker */
+export type DOCommand =
+  | { type: "fetch"; url: string; method: string; headers: [string, string][]; body: ArrayBuffer | null }
+  | { type: "rpc-call"; method: string; args: unknown[] }
+  | { type: "rpc-get"; prop: string }
+  | { type: "alarm"; retryCount: number }
+  | { type: "ws-create"; wsId: string };
+
+/** Results returned from worker to main thread */
+export type DOResult =
+  | { type: "fetch"; status: number; statusText: string; headers: [string, string][]; body: ArrayBuffer | null }
+  | { type: "rpc-call"; value: unknown }
+  | { type: "rpc-get"; value: unknown }
+  | { type: "alarm" }
+  | { type: "ws-created"; wsId: string }
+  | { type: "error"; message: string; stack?: string; name?: string };
+
+/** Messages from main thread → worker */
+export type DOWorkerMessage =
+  | { type: "command"; id: number; command: DOCommand }
+  | { type: "ws-message"; wsId: string; data: string | ArrayBuffer }
+  | { type: "ws-close"; wsId: string; code: number; reason: string; wasClean: boolean }
+  | { type: "ws-error"; wsId: string };
+
+/** Messages from worker → main thread */
+export type DOMainMessage =
+  | { type: "need-init" }
+  | { type: "ready" }
+  | { type: "result"; id: number; result: DOResult }
+  | { type: "alarm-set"; time: number | null }
+  | { type: "ws-bridge"; payload: WsBridgeOutbound };
+
+// --- Pending command tracking ---
+
+interface PendingCommand {
+  resolve: (result: DOResult) => void;
+  reject: (error: Error) => void;
+}
+
+// --- WorkerExecutor ---
+
+const WORKER_ENTRY_PATH = resolve(dirname(new URL(import.meta.url).pathname), "do-worker-entry.ts");
+
+export class WorkerExecutor implements DOExecutor {
+  private _config: ExecutorConfig;
+  private _worker: Worker | null = null;
+  private _ready: Promise<void> | null = null;
+  private _readyResolve: (() => void) | null = null;
+  private _pending = new Map<number, PendingCommand>();
+  private _nextId = 1;
+  private _disposed = false;
+  private _inFlightCount = 0;
+  private _blocked = false;
+  private _wsCount = 0;
+  private _bridgedWebSockets = new Map<string, WebSocket>();
+
+  constructor(config: ExecutorConfig) {
+    this._config = config;
+  }
+
+  private _ensureWorker(): Worker {
+    if (this._disposed) throw new Error("WorkerExecutor has been disposed");
+    if (this._worker) return this._worker;
+
+    const config = this._config;
+    const worker = new Worker(WORKER_ENTRY_PATH);
+
+    this._ready = new Promise<void>((resolve) => {
+      this._readyResolve = resolve;
+    });
+
+    worker.onmessage = (event: MessageEvent<DOMainMessage>) => {
+      const msg = event.data;
+
+      switch (msg.type) {
+        case "need-init":
+          // Worker is alive, send configuration
+          worker.postMessage({
+            type: "init",
+            config: {
+              modulePath: this._resolveModulePath(),
+              configPath: this._resolveConfigPath(),
+              dataDir: this._resolveDataDir(),
+              namespaceName: config.namespaceName,
+              idStr: config.id.toString(),
+              idName: config.id.name,
+            },
+          });
+          break;
+
+        case "ready":
+          this._readyResolve?.();
+          break;
+
+        case "result": {
+          if (msg.id === -1 && msg.result.type === "error") {
+            // Worker init error — reject all pending and the ready promise
+            const error = new Error(msg.result.message);
+            if (msg.result.stack) error.stack = msg.result.stack;
+            for (const [, pending] of this._pending) {
+              pending.reject(error);
+            }
+            this._pending.clear();
+            // Resolve ready so _sendCommand doesn't hang forever
+            this._readyResolve?.();
+            this._disposed = true;
+            break;
+          }
+          const pending = this._pending.get(msg.id);
+          if (pending) {
+            this._pending.delete(msg.id);
+            pending.resolve(msg.result);
+          }
+          break;
+        }
+
+        case "alarm-set":
+          // Forward alarm set/delete to namespace via callback
+          config.onAlarmSet?.(msg.time);
+          break;
+
+        case "ws-bridge":
+          this._handleWsBridge(msg.payload);
+          break;
+      }
+    };
+
+    worker.onerror = (event) => {
+      // Reject all pending commands
+      const error = new Error(`Worker error: ${event.message}`);
+      for (const [id, pending] of this._pending) {
+        pending.reject(error);
+      }
+      this._pending.clear();
+    };
+
+    this._worker = worker;
+    return worker;
+  }
+
+  private _resolveModulePath(): string {
+    return (this._config as any)._modulePath ?? "";
+  }
+
+  private _resolveConfigPath(): string {
+    return (this._config as any)._configPath ?? "";
+  }
+
+  private _resolveDataDir(): string {
+    return this._config.dataDir ?? "";
+  }
+
+  private async _sendCommand(command: DOCommand): Promise<DOResult> {
+    const worker = this._ensureWorker();
+    await this._ready;
+
+    if (this._disposed) throw new Error("Worker terminated");
+
+    const id = this._nextId++;
+    this._inFlightCount++;
+
+    return new Promise<DOResult>((resolve, reject) => {
+      this._pending.set(id, {
+        resolve: (result) => {
+          this._inFlightCount--;
+          if (result.type === "error") {
+            const err = new Error(result.message);
+            err.name = result.name ?? "Error";
+            if (result.stack) err.stack = result.stack;
+            reject(err);
+          } else {
+            resolve(result);
+          }
+        },
+        reject: (err) => {
+          this._inFlightCount--;
+          reject(err);
+        },
+      });
+      worker.postMessage({ type: "command", id, command } satisfies DOWorkerMessage);
+    });
+  }
+
+  private _handleWsBridge(payload: WsBridgeOutbound): void {
+    switch (payload.type) {
+      case "ws-send": {
+        const ws = this._bridgedWebSockets.get(payload.wsId);
+        if (ws && ws.readyState === 1) {
+          ws.send(payload.data);
+        }
+        break;
+      }
+      case "ws-close": {
+        const ws = this._bridgedWebSockets.get(payload.wsId);
+        if (ws) {
+          ws.close(payload.code, payload.reason);
+          this._bridgedWebSockets.delete(payload.wsId);
+          this._wsCount--;
+        }
+        break;
+      }
+      case "ws-accept": {
+        // WebSocket was accepted by the DO — increment count
+        this._wsCount++;
+        break;
+      }
+    }
+  }
+
+  /** Register a real WebSocket for bridging to the worker */
+  _bridgeWebSocket(wsId: string, ws: WebSocket): void {
+    this._bridgedWebSockets.set(wsId, ws);
+
+    // Forward events from real WS to worker
+    ws.addEventListener("message", (event: MessageEvent) => {
+      this._worker?.postMessage({
+        type: "ws-message",
+        wsId,
+        data: event.data,
+      } satisfies DOWorkerMessage);
+    });
+
+    ws.addEventListener("close", (event: CloseEvent) => {
+      this._worker?.postMessage({
+        type: "ws-close",
+        wsId,
+        code: event.code,
+        reason: event.reason,
+        wasClean: event.wasClean,
+      } satisfies DOWorkerMessage);
+      this._bridgedWebSockets.delete(wsId);
+    });
+
+    ws.addEventListener("error", () => {
+      this._worker?.postMessage({
+        type: "ws-error",
+        wsId,
+      } satisfies DOWorkerMessage);
+    });
+  }
+
+  // --- DOExecutor interface ---
+
+  async executeFetch(request: Request): Promise<Response> {
+    // Serialize Request
+    const headers: [string, string][] = [];
+    request.headers.forEach((v, k) => headers.push([k, v]));
+    const body = request.body ? await request.arrayBuffer() : null;
+
+    const result = await this._sendCommand({
+      type: "fetch",
+      url: request.url,
+      method: request.method,
+      headers,
+      body,
+    });
+
+    if (result.type !== "fetch") throw new Error("Unexpected result type");
+
+    // Reconstruct Response
+    return new Response(result.body, {
+      status: result.status,
+      statusText: result.statusText,
+      headers: result.headers,
+    });
+  }
+
+  async executeRpc(method: string, args: unknown[]): Promise<unknown> {
+    const result = await this._sendCommand({
+      type: "rpc-call",
+      method,
+      args,
+    });
+
+    if (result.type !== "rpc-call") throw new Error("Unexpected result type");
+    return result.value;
+  }
+
+  async executeRpcGet(prop: string): Promise<unknown> {
+    const result = await this._sendCommand({
+      type: "rpc-get",
+      prop,
+    });
+
+    if (result.type !== "rpc-get") throw new Error("Unexpected result type");
+    // Functions can't cross the boundary — return a callable stub
+    if (result.value === "__function__") {
+      return (...args: unknown[]) => this.executeRpc(prop, args);
+    }
+    return result.value;
+  }
+
+  async executeAlarm(retryCount: number): Promise<void> {
+    const result = await this._sendCommand({
+      type: "alarm",
+      retryCount,
+    });
+    if (result.type === "error") {
+      const err = new Error(result.message);
+      if (result.stack) err.stack = result.stack;
+      throw err;
+    }
+  }
+
+  isActive(): boolean {
+    return this._inFlightCount > 0;
+  }
+
+  isBlocked(): boolean {
+    return this._blocked;
+  }
+
+  activeWebSocketCount(): number {
+    return this._wsCount;
+  }
+
+  async dispose(): Promise<void> {
+    this._disposed = true;
+    if (this._worker) {
+      this._worker.terminate();
+      this._worker = null;
+    }
+    // Reject all pending commands
+    const error = new Error("Worker terminated");
+    for (const [, pending] of this._pending) {
+      pending.reject(error);
+    }
+    this._pending.clear();
+    this._bridgedWebSockets.clear();
+  }
+}
+
+// --- Factory ---
+
+export class WorkerExecutorFactory implements DOExecutorFactory {
+  private _modulePath?: string;
+  private _configPath?: string;
+
+  /**
+   * Set the module and config paths for all executors created by this factory.
+   * Called by the generation manager after loading config.
+   */
+  configure(modulePath: string, configPath: string): void {
+    this._modulePath = modulePath;
+    this._configPath = configPath;
+  }
+
+  create(config: ExecutorConfig): DOExecutor {
+    // Attach paths to the config for the executor to use
+    const extendedConfig = config as any;
+    extendedConfig._modulePath = this._modulePath ?? "";
+    extendedConfig._configPath = this._configPath ?? "";
+    return new WorkerExecutor(extendedConfig);
+  }
+}

package/runtime/bindings/do-executor.ts

@@ -0,0 +1,45 @@
+import type { Database } from "bun:sqlite";
+import type { DurableObjectIdImpl, DurableObjectBase, DurableObjectLimits } from "./durable-object";
+import type { ContainerConfig } from "./container";
+
+export interface ExecutorConfig {
+  id: DurableObjectIdImpl;
+  db: Database;
+  namespaceName: string;
+  cls: new (ctx: any, env: unknown) => DurableObjectBase;
+  env: unknown;
+  dataDir?: string;
+  limits?: DurableObjectLimits;
+  containerConfig?: ContainerConfig;
+  onAlarmSet?: (time: number | null) => void;
+}
+
+export interface DOExecutor {
+  /** Execute a fetch call on the DO instance */
+  executeFetch(request: Request): Promise<Response>;
+
+  /** Execute an RPC method call */
+  executeRpc(method: string, args: unknown[]): Promise<unknown>;
+
+  /** Execute an RPC property get */
+  executeRpcGet(prop: string): Promise<unknown>;
+
+  /** Execute the alarm handler */
+  executeAlarm(retryCount: number): Promise<void>;
+
+  /** Whether the instance has in-flight requests */
+  isActive(): boolean;
+
+  /** Whether blockConcurrencyWhile is running */
+  isBlocked(): boolean;
+
+  /** Count of accepted WebSockets */
+  activeWebSocketCount(): number;
+
+  /** Kill the instance */
+  dispose(): Promise<void>;
+}
+
+export interface DOExecutorFactory {
+  create(config: ExecutorConfig): DOExecutor;
+}

package/runtime/bindings/do-websocket-bridge.ts

@@ -0,0 +1,70 @@
+/**
+ * WebSocket bridge for isolated DO mode.
+ *
+ * Real WebSocket lives in the main thread (Bun.serve). The worker thread
+ * gets a BridgeWebSocket proxy that forwards send/close via postMessage.
+ * The main thread forwards incoming message/close/error events to the worker.
+ *
+ * Each bridged WebSocket is identified by a unique wsId.
+ */
+
+// --- Messages from worker → main ---
+export type WsBridgeOutbound =
+  | { type: "ws-send"; wsId: string; data: string | ArrayBuffer }
+  | { type: "ws-close"; wsId: string; code?: number; reason?: string }
+  | { type: "ws-accept"; wsId: string; tags: string[] };
+
+// --- Messages from main → worker ---
+export type WsBridgeInbound =
+  | { type: "ws-message"; wsId: string; data: string | ArrayBuffer }
+  | { type: "ws-close"; wsId: string; code: number; reason: string; wasClean: boolean }
+  | { type: "ws-error"; wsId: string };
+
+/**
+ * A WebSocket proxy that lives in the worker thread.
+ * Implements enough of the WebSocket interface for DO's state.acceptWebSocket().
+ */
+export class BridgeWebSocket extends EventTarget {
+  readonly wsId: string;
+  readyState = 1; // OPEN
+  private _postMessage: (msg: WsBridgeOutbound) => void;
+
+  constructor(wsId: string, postMessage: (msg: WsBridgeOutbound) => void) {
+    super();
+    this.wsId = wsId;
+    this._postMessage = postMessage;
+  }
+
+  send(data: string | ArrayBuffer): void {
+    if (this.readyState !== 1) return;
+    this._postMessage({ type: "ws-send", wsId: this.wsId, data });
+  }
+
+  close(code?: number, reason?: string): void {
+    if (this.readyState >= 2) return;
+    this.readyState = 2; // CLOSING
+    this._postMessage({ type: "ws-close", wsId: this.wsId, code, reason });
+    this.readyState = 3; // CLOSED
+  }
+
+  /** @internal Called by the worker entry when the main thread forwards a message */
+  _onMessage(data: string | ArrayBuffer): void {
+    this.dispatchEvent(new MessageEvent("message", { data }));
+  }
+
+  /** @internal Called by the worker entry when the main thread forwards a close */
+  _onClose(code: number, reason: string, wasClean: boolean): void {
+    this.readyState = 3;
+    this.dispatchEvent(new CloseEvent("close", { code, reason, wasClean }));
+  }
+
+  /** @internal Called by the worker entry when the main thread forwards an error */
+  _onError(): void {
+    this.dispatchEvent(new Event("error"));
+  }
+
+  /** Signal that this WS has been accepted by the DO (via state.acceptWebSocket) */
+  _signalAccepted(tags: string[]): void {
+    this._postMessage({ type: "ws-accept", wsId: this.wsId, tags });
+  }
+}

package/runtime/bindings/do-worker-entry.ts

@@ -0,0 +1,220 @@
+/**
+ * Worker thread entry point for isolated DO mode.
+ *
+ * Spawned by WorkerExecutor. Receives configuration via the first
+ * postMessage from the main thread (handshake), then initializes.
+ */
+
+import type { DOCommand, DOResult, DOWorkerMessage, DOMainMessage } from "./do-executor-worker";
+
+declare var self: Worker;
+
+interface WorkerConfig {
+  modulePath: string;
+  configPath: string;
+  dataDir: string;
+  namespaceName: string;
+  idStr: string;
+  idName?: string;
+}
+
+// Wait for init config from main thread, then set up the worker
+self.onmessage = async (event: MessageEvent) => {
+  const msg = event.data;
+  if (msg.type !== "init") return;
+
+  const workerConfig: WorkerConfig = msg.config;
+
+  try {
+    await initWorker(workerConfig);
+  } catch (e) {
+    const error = e instanceof Error ? e : new Error(String(e));
+    postMessage({
+      type: "result",
+      id: -1,
+      result: {
+        type: "error",
+        message: `Worker init failed: ${error.message}`,
+        stack: error.stack,
+        name: error.name,
+      },
+    } satisfies DOMainMessage);
+  }
+};
+
+// Signal that we're alive and waiting for config
+postMessage({ type: "need-init" });
+
+async function initWorker(workerConfig: WorkerConfig) {
+  // Register Bun plugins for cloudflare:workers etc.
+  await import("../plugin");
+
+  const { loadConfig } = await import("../config");
+  const { buildWorkerEnv } = await import("./do-worker-env");
+  const { DurableObjectStateImpl, DurableObjectIdImpl } = await import("./durable-object");
+  const { BridgeWebSocket } = await import("./do-websocket-bridge");
+
+  const config = await loadConfig(workerConfig.configPath);
+  const { db, env, doNamespaces } = buildWorkerEnv(config, workerConfig.dataDir);
+
+  // Import user's worker module
+  const workerModule = await import(workerConfig.modulePath);
+
+  // Wire DO classes for nested DOs
+  for (const entry of doNamespaces) {
+    const cls = workerModule[entry.className];
+    if (cls) {
+      entry.namespace._setClass(cls as any, env);
+    }
+  }
+
+  // Create this DO's instance
+  const id = new DurableObjectIdImpl(workerConfig.idStr, workerConfig.idName);
+  const cls = workerModule[workerConfig.namespaceName];
+  if (!cls) {
+    throw new Error(`DO class "${workerConfig.namespaceName}" not exported from worker module`);
+  }
+
+  const state = new DurableObjectStateImpl(id, db, workerConfig.namespaceName, workerConfig.dataDir);
+  const instance = new (cls as any)(state, env);
+
+  state._setInstanceResolver(() => instance);
+
+  const bridgedWebSockets = new Map<string, InstanceType<typeof BridgeWebSocket>>();
+
+  // Wire alarm callback
+  state.storage._setAlarmCallback((time: number | null) => {
+    postMessage({ type: "alarm-set", time } satisfies DOMainMessage);
+  });
+
+  // --- Command handler ---
+
+  async function handleCommand(cmd: DOCommand): Promise<DOResult> {
+    switch (cmd.type) {
+      case "fetch": {
+        const unlock = await state._lock();
+        try {
+          await state._waitForReady();
+          const fetchFn = (instance as any).fetch;
+          if (typeof fetchFn !== "function") {
+            throw new Error("Durable Object does not implement fetch()");
+          }
+          const request = new Request(cmd.url, {
+            method: cmd.method,
+            headers: cmd.headers,
+            body: cmd.body,
+          });
+          const response = await fetchFn.call(instance, request);
+          const resBody = response.body ? await response.arrayBuffer() : null;
+          const resHeaders: [string, string][] = [];
+          response.headers.forEach((v: string, k: string) => resHeaders.push([k, v]));
+          return {
+            type: "fetch",
+            status: response.status,
+            statusText: response.statusText,
+            headers: resHeaders,
+            body: resBody,
+          };
+        } finally {
+          unlock();
+        }
+      }
+
+      case "rpc-call": {
+        const unlock = await state._lock();
+        try {
+          await state._waitForReady();
+          const val = (instance as any)[cmd.method];
+          if (typeof val !== "function") {
+            throw new Error(`"${cmd.method}" is not a method on the Durable Object`);
+          }
+          const result = await val.call(instance, ...cmd.args);
+          return { type: "rpc-call", value: result };
+        } finally {
+          unlock();
+        }
+      }
+
+      case "rpc-get": {
+        const unlock = await state._lock();
+        try {
+          await state._waitForReady();
+          const val = (instance as any)[cmd.prop];
+          if (typeof val === "function") {
+            return { type: "rpc-get", value: "__function__" };
+          }
+          return { type: "rpc-get", value: val };
+        } finally {
+          unlock();
+        }
+      }
+
+      case "alarm": {
+        const unlock = await state._lock();
+        try {
+          await state._waitForReady();
+          const alarmFn = (instance as any).alarm;
+          if (typeof alarmFn === "function") {
+            await alarmFn.call(instance, {
+              retryCount: cmd.retryCount,
+              isRetry: cmd.retryCount > 0,
+            });
+          }
+          return { type: "alarm" };
+        } finally {
+          unlock();
+        }
+      }
+
+      case "ws-create": {
+        const bridgeWs = new BridgeWebSocket(cmd.wsId, (msg: any) => {
+          postMessage({ type: "ws-bridge", payload: msg } satisfies DOMainMessage);
+        });
+        bridgedWebSockets.set(cmd.wsId, bridgeWs);
+        return { type: "ws-created", wsId: cmd.wsId };
+      }
+
+      default:
+        throw new Error(`Unknown command type: ${(cmd as any).type}`);
+    }
+  }
+
+  // Replace the init handler with the command handler
+  self.onmessage = async (event: MessageEvent<DOWorkerMessage>) => {
+    const msg = event.data;
+
+    if (msg.type === "command") {
+      try {
+        const result = await handleCommand(msg.command);
+        postMessage({ type: "result", id: msg.id, result } satisfies DOMainMessage);
+      } catch (e) {
+        const error = e instanceof Error ? e : new Error(String(e));
+        postMessage({
+          type: "result",
+          id: msg.id,
+          result: {
+            type: "error",
+            message: error.message,
+            stack: error.stack,
+            name: error.name,
+          },
+        } satisfies DOMainMessage);
+      }
+    } else if (msg.type === "ws-message") {
+      const ws = bridgedWebSockets.get(msg.wsId);
+      if (ws) ws._onMessage(msg.data);
+    } else if (msg.type === "ws-close") {
+      const ws = bridgedWebSockets.get(msg.wsId);
+      if (ws) {
+        ws._onClose(msg.code, msg.reason, msg.wasClean);
+        bridgedWebSockets.delete(msg.wsId);
+      }
+    } else if (msg.type === "ws-error") {
+      const ws = bridgedWebSockets.get(msg.wsId);
+      if (ws) ws._onError();
+    }
+  };
+
+  // Signal ready
+  postMessage({ type: "ready" } satisfies DOMainMessage);
+}