@tracecode/harness 0.4.0

package/dist/internal/browser.js

@@ -0,0 +1,617 @@
+// packages/harness-browser/src/pyodide-worker-client.ts
+var EXECUTION_TIMEOUT_MS = 1e4;
+var INTERVIEW_MODE_TIMEOUT_MS = 5e3;
+var TRACING_TIMEOUT_MS = 3e4;
+var INIT_TIMEOUT_MS = 12e4;
+var MESSAGE_TIMEOUT_MS = 2e4;
+var WORKER_READY_TIMEOUT_MS = 1e4;
+var PyodideWorkerClient = class {
+  constructor(options) {
+    this.options = options;
+    this.debug = options.debug ?? process.env.NODE_ENV === "development";
+  }
+  worker = null;
+  pendingMessages = /* @__PURE__ */ new Map();
+  messageId = 0;
+  isInitializing = false;
+  initPromise = null;
+  workerReadyPromise = null;
+  workerReadyResolve = null;
+  workerReadyReject = null;
+  debug;
+  /**
+   * Check if Web Workers are supported
+   */
+  isSupported() {
+    return typeof Worker !== "undefined";
+  }
+  /**
+   * Get or create the worker instance
+   */
+  getWorker() {
+    if (this.worker) return this.worker;
+    if (!this.isSupported()) {
+      throw new Error("Web Workers are not supported in this environment");
+    }
+    this.workerReadyPromise = new Promise((resolve, reject) => {
+      this.workerReadyResolve = resolve;
+      this.workerReadyReject = (error) => reject(error);
+    });
+    const workerUrl = this.debug && !this.options.workerUrl.includes("?") ? `${this.options.workerUrl}?dev=${Date.now()}` : this.options.workerUrl;
+    this.worker = new Worker(workerUrl);
+    this.worker.onmessage = (event) => {
+      const { id, type, payload } = event.data;
+      if (type === "worker-ready") {
+        this.workerReadyResolve?.();
+        this.workerReadyResolve = null;
+        this.workerReadyReject = null;
+        if (this.debug) console.log("[PyodideWorkerClient] worker-ready");
+        return;
+      }
+      if (this.debug && !id) {
+        console.log("[PyodideWorkerClient] event", { type, payload });
+      }
+      if (id) {
+        const pending = this.pendingMessages.get(id);
+        if (pending) {
+          this.pendingMessages.delete(id);
+          if (pending.timeoutId) globalThis.clearTimeout(pending.timeoutId);
+          if (type === "error") {
+            pending.reject(new Error(payload.error));
+          } else {
+            if (this.debug) console.log("[PyodideWorkerClient] recv", { id, type });
+            pending.resolve(payload);
+          }
+        }
+      }
+    };
+    this.worker.onerror = (error) => {
+      console.error("[PyodideWorkerClient] Worker error:", error);
+      const workerError = new Error("Worker error");
+      this.workerReadyReject?.(workerError);
+      this.workerReadyResolve = null;
+      this.workerReadyReject = null;
+      for (const [id, pending] of this.pendingMessages) {
+        if (pending.timeoutId) {
+          globalThis.clearTimeout(pending.timeoutId);
+        }
+        pending.reject(workerError);
+        this.pendingMessages.delete(id);
+      }
+    };
+    return this.worker;
+  }
+  /**
+   * Wait for worker bootstrap signal with timeout.
+   * Guards against deadlocks when the worker script fails before posting "worker-ready".
+   */
+  async waitForWorkerReady() {
+    const readyPromise = this.workerReadyPromise;
+    if (!readyPromise) return;
+    await new Promise((resolve, reject) => {
+      let settled = false;
+      const timeoutId = globalThis.setTimeout(() => {
+        if (settled) return;
+        settled = true;
+        const timeoutError = new Error(
+          `Python worker failed to initialize in time (${Math.round(WORKER_READY_TIMEOUT_MS / 1e3)}s)`
+        );
+        if (this.debug) {
+          console.warn("[PyodideWorkerClient] worker-ready timeout", { timeoutMs: WORKER_READY_TIMEOUT_MS });
+        }
+        this.terminateAndReset(timeoutError);
+        reject(timeoutError);
+      }, WORKER_READY_TIMEOUT_MS);
+      readyPromise.then(() => {
+        if (settled) return;
+        settled = true;
+        globalThis.clearTimeout(timeoutId);
+        resolve();
+      }).catch((error) => {
+        if (settled) return;
+        settled = true;
+        globalThis.clearTimeout(timeoutId);
+        reject(error instanceof Error ? error : new Error(String(error)));
+      });
+    });
+  }
+  /**
+   * Send a message to the worker and wait for a response
+   */
+  async sendMessage(type, payload, timeoutMs = MESSAGE_TIMEOUT_MS) {
+    const worker = this.getWorker();
+    await this.waitForWorkerReady();
+    const id = String(++this.messageId);
+    return new Promise((resolve, reject) => {
+      this.pendingMessages.set(id, {
+        resolve,
+        reject
+      });
+      if (this.debug) console.log("[PyodideWorkerClient] send", { id, type });
+      const timeoutId = globalThis.setTimeout(() => {
+        const pending2 = this.pendingMessages.get(id);
+        if (!pending2) return;
+        this.pendingMessages.delete(id);
+        if (this.debug) console.warn("[PyodideWorkerClient] timeout", { id, type });
+        pending2.reject(new Error(`Worker request timed out: ${type}`));
+      }, timeoutMs);
+      const pending = this.pendingMessages.get(id);
+      if (pending) pending.timeoutId = timeoutId;
+      worker.postMessage({ id, type, payload });
+    });
+  }
+  /**
+   * Execute code with a timeout - terminates worker if execution takes too long
+   */
+  async executeWithTimeout(executor, timeoutMs = EXECUTION_TIMEOUT_MS) {
+    return new Promise((resolve, reject) => {
+      let settled = false;
+      const timeoutId = globalThis.setTimeout(() => {
+        if (settled) return;
+        settled = true;
+        if (this.debug) {
+          console.warn("[PyodideWorkerClient] Execution timeout - terminating worker");
+        }
+        this.terminateAndReset();
+        const seconds = Math.round(timeoutMs / 1e3);
+        reject(new Error(`Execution timed out (possible infinite loop). Code execution was stopped after ${seconds} seconds.`));
+      }, timeoutMs);
+      executor().then((result) => {
+        if (settled) return;
+        settled = true;
+        globalThis.clearTimeout(timeoutId);
+        resolve(result);
+      }).catch((error) => {
+        if (settled) return;
+        settled = true;
+        globalThis.clearTimeout(timeoutId);
+        reject(error);
+      });
+    });
+  }
+  /**
+   * Terminate the worker and reset state for recreation
+   */
+  terminateAndReset(reason = new Error("Worker was terminated")) {
+    this.workerReadyReject?.(reason);
+    if (this.worker) {
+      this.worker.terminate();
+      this.worker = null;
+    }
+    this.initPromise = null;
+    this.isInitializing = false;
+    this.workerReadyPromise = null;
+    this.workerReadyResolve = null;
+    for (const [, pending] of this.pendingMessages) {
+      if (pending.timeoutId) globalThis.clearTimeout(pending.timeoutId);
+      pending.reject(reason);
+    }
+    this.pendingMessages.clear();
+  }
+  /**
+   * Initialize Pyodide in the worker
+   */
+  async init() {
+    if (this.initPromise) {
+      return this.initPromise;
+    }
+    if (this.isInitializing) {
+      await new Promise((resolve) => setTimeout(resolve, 100));
+      return this.init();
+    }
+    this.isInitializing = true;
+    this.initPromise = (async () => {
+      try {
+        return await this.sendMessage("init", void 0, INIT_TIMEOUT_MS);
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        const shouldRetry = message.includes("Worker request timed out: init") || message.includes("Worker was terminated") || message.includes("Worker error") || message.includes("failed to initialize in time");
+        if (!shouldRetry) {
+          throw error;
+        }
+        if (this.debug) {
+          console.warn("[PyodideWorkerClient] init failed, resetting worker and retrying once", { message });
+        }
+        this.terminateAndReset();
+        return this.sendMessage("init", void 0, INIT_TIMEOUT_MS);
+      }
+    })();
+    try {
+      const result = await this.initPromise;
+      return result;
+    } catch (error) {
+      this.initPromise = null;
+      throw error;
+    } finally {
+      this.isInitializing = false;
+    }
+  }
+  /**
+   * Execute Python code with tracing for step-by-step visualization
+   * @param options.maxLineEvents - Max line events before abort (for complexity analysis, use higher values)
+   */
+  async executeWithTracing(code, functionName, inputs, options, executionStyle = "function") {
+    await this.init();
+    try {
+      return await this.executeWithTimeout(
+        () => this.sendMessage("execute-with-tracing", {
+          code,
+          functionName,
+          inputs,
+          executionStyle,
+          options
+        }, TRACING_TIMEOUT_MS + 5e3),
+        // Message timeout slightly longer than execution timeout
+        TRACING_TIMEOUT_MS
+      );
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      const isClientTimeout = errorMessage.includes("Execution timed out") || errorMessage.includes("possible infinite loop");
+      if (isClientTimeout) {
+        return {
+          success: false,
+          error: errorMessage,
+          trace: [],
+          executionTimeMs: TRACING_TIMEOUT_MS,
+          consoleOutput: [],
+          traceLimitExceeded: true,
+          timeoutReason: "client-timeout",
+          lineEventCount: 0,
+          traceStepCount: 0
+        };
+      }
+      throw error;
+    }
+  }
+  /**
+   * Execute Python code without tracing (for running tests)
+   */
+  async executeCode(code, functionName, inputs, executionStyle = "function") {
+    await this.init();
+    return this.executeWithTimeout(
+      () => this.sendMessage("execute-code", {
+        code,
+        functionName,
+        inputs,
+        executionStyle
+      }, EXECUTION_TIMEOUT_MS + 5e3),
+      EXECUTION_TIMEOUT_MS
+    );
+  }
+  /**
+   * Execute Python code in interview mode - 5 second timeout, generic error messages
+   * Does not reveal which line caused the timeout
+   */
+  async executeCodeInterviewMode(code, functionName, inputs, executionStyle = "function") {
+    await this.init();
+    try {
+      const result = await this.executeWithTimeout(
+        () => this.sendMessage("execute-code-interview", {
+          code,
+          functionName,
+          inputs,
+          executionStyle
+        }, INTERVIEW_MODE_TIMEOUT_MS + 2e3),
+        INTERVIEW_MODE_TIMEOUT_MS
+      );
+      if (!result.success && result.error) {
+        const normalizedError = result.error.toLowerCase();
+        const isTimeoutOrResourceLimit = normalizedError.includes("timed out") || normalizedError.includes("execution timeout") || normalizedError.includes("infinite loop") || normalizedError.includes("interview_guard_triggered") || normalizedError.includes("memory-limit") || normalizedError.includes("line-limit") || normalizedError.includes("single-line-limit") || normalizedError.includes("recursion-limit");
+        if (isTimeoutOrResourceLimit) {
+          return {
+            success: false,
+            output: null,
+            error: "Time Limit Exceeded",
+            consoleOutput: result.consoleOutput ?? []
+          };
+        }
+      }
+      return result;
+    } catch (error) {
+      const errorMsg = error instanceof Error ? error.message : String(error);
+      if (errorMsg.includes("timed out") || errorMsg.includes("Execution timeout")) {
+        return {
+          success: false,
+          output: null,
+          error: "Time Limit Exceeded",
+          consoleOutput: []
+        };
+      }
+      return {
+        success: false,
+        output: null,
+        error: errorMsg,
+        consoleOutput: []
+      };
+    }
+  }
+  /**
+   * Check the status of the worker
+   */
+  async getStatus() {
+    return this.sendMessage("status");
+  }
+  /**
+   * Analyze Python code using AST (off main thread)
+   * Returns CodeFacts with semantic information about the code
+   */
+  async analyzeCode(code) {
+    await this.init();
+    return this.sendMessage("analyze-code", { code }, 5e3);
+  }
+  /**
+   * Terminate the worker and clean up resources
+   */
+  terminate() {
+    this.terminateAndReset();
+  }
+};
+function isWorkerSupported() {
+  return typeof Worker !== "undefined";
+}
+
+// packages/harness-browser/src/javascript-worker-client.ts
+var EXECUTION_TIMEOUT_MS2 = 7e3;
+var INTERVIEW_MODE_TIMEOUT_MS2 = 5e3;
+var TRACING_TIMEOUT_MS2 = 7e3;
+var INIT_TIMEOUT_MS2 = 1e4;
+var MESSAGE_TIMEOUT_MS2 = 12e3;
+var WORKER_READY_TIMEOUT_MS2 = 1e4;
+var JavaScriptWorkerClient = class {
+  constructor(options) {
+    this.options = options;
+    this.debug = options.debug ?? process.env.NODE_ENV === "development";
+  }
+  worker = null;
+  pendingMessages = /* @__PURE__ */ new Map();
+  messageId = 0;
+  isInitializing = false;
+  initPromise = null;
+  workerReadyPromise = null;
+  workerReadyResolve = null;
+  workerReadyReject = null;
+  debug;
+  isSupported() {
+    return typeof Worker !== "undefined";
+  }
+  getWorker() {
+    if (this.worker) return this.worker;
+    if (!this.isSupported()) {
+      throw new Error("Web Workers are not supported in this environment");
+    }
+    this.workerReadyPromise = new Promise((resolve, reject) => {
+      this.workerReadyResolve = resolve;
+      this.workerReadyReject = (error) => reject(error);
+    });
+    const workerUrl = this.debug && !this.options.workerUrl.includes("?") ? `${this.options.workerUrl}?dev=${Date.now()}` : this.options.workerUrl;
+    this.worker = new Worker(workerUrl);
+    this.worker.onmessage = (event) => {
+      const { id, type, payload } = event.data;
+      if (type === "worker-ready") {
+        this.workerReadyResolve?.();
+        this.workerReadyResolve = null;
+        this.workerReadyReject = null;
+        if (this.debug) console.log("[JavaScriptWorkerClient] worker-ready");
+        return;
+      }
+      if (id) {
+        const pending = this.pendingMessages.get(id);
+        if (!pending) return;
+        this.pendingMessages.delete(id);
+        if (pending.timeoutId) globalThis.clearTimeout(pending.timeoutId);
+        if (type === "error") {
+          pending.reject(new Error(payload.error));
+          return;
+        }
+        pending.resolve(payload);
+      }
+    };
+    this.worker.onerror = (error) => {
+      console.error("[JavaScriptWorkerClient] Worker error:", error);
+      const workerError = new Error("Worker error");
+      this.workerReadyReject?.(workerError);
+      this.workerReadyResolve = null;
+      this.workerReadyReject = null;
+      for (const [id, pending] of this.pendingMessages) {
+        if (pending.timeoutId) globalThis.clearTimeout(pending.timeoutId);
+        pending.reject(workerError);
+        this.pendingMessages.delete(id);
+      }
+    };
+    return this.worker;
+  }
+  async waitForWorkerReady() {
+    const readyPromise = this.workerReadyPromise;
+    if (!readyPromise) return;
+    await new Promise((resolve, reject) => {
+      let settled = false;
+      const timeoutId = globalThis.setTimeout(() => {
+        if (settled) return;
+        settled = true;
+        const timeoutError = new Error(
+          `JavaScript worker failed to initialize in time (${Math.round(WORKER_READY_TIMEOUT_MS2 / 1e3)}s)`
+        );
+        this.terminateAndReset(timeoutError);
+        reject(timeoutError);
+      }, WORKER_READY_TIMEOUT_MS2);
+      readyPromise.then(() => {
+        if (settled) return;
+        settled = true;
+        globalThis.clearTimeout(timeoutId);
+        resolve();
+      }).catch((error) => {
+        if (settled) return;
+        settled = true;
+        globalThis.clearTimeout(timeoutId);
+        reject(error instanceof Error ? error : new Error(String(error)));
+      });
+    });
+  }
+  async sendMessage(type, payload, timeoutMs = MESSAGE_TIMEOUT_MS2) {
+    const worker = this.getWorker();
+    await this.waitForWorkerReady();
+    const id = String(++this.messageId);
+    return new Promise((resolve, reject) => {
+      this.pendingMessages.set(id, {
+        resolve,
+        reject
+      });
+      const timeoutId = globalThis.setTimeout(() => {
+        const pending2 = this.pendingMessages.get(id);
+        if (!pending2) return;
+        this.pendingMessages.delete(id);
+        pending2.reject(new Error(`Worker request timed out: ${type}`));
+      }, timeoutMs);
+      const pending = this.pendingMessages.get(id);
+      if (pending) pending.timeoutId = timeoutId;
+      worker.postMessage({ id, type, payload });
+    });
+  }
+  async executeWithTimeout(executor, timeoutMs) {
+    return new Promise((resolve, reject) => {
+      let settled = false;
+      const timeoutId = globalThis.setTimeout(() => {
+        if (settled) return;
+        settled = true;
+        this.terminateAndReset();
+        reject(
+          new Error(
+            `Execution timed out (possible infinite loop). Code execution was stopped after ${Math.round(timeoutMs / 1e3)} seconds.`
+          )
+        );
+      }, timeoutMs);
+      executor().then((result) => {
+        if (settled) return;
+        settled = true;
+        globalThis.clearTimeout(timeoutId);
+        resolve(result);
+      }).catch((error) => {
+        if (settled) return;
+        settled = true;
+        globalThis.clearTimeout(timeoutId);
+        reject(error);
+      });
+    });
+  }
+  terminateAndReset(reason = new Error("Worker was terminated")) {
+    this.workerReadyReject?.(reason);
+    if (this.worker) {
+      this.worker.terminate();
+      this.worker = null;
+    }
+    this.initPromise = null;
+    this.isInitializing = false;
+    this.workerReadyPromise = null;
+    this.workerReadyResolve = null;
+    this.workerReadyReject = null;
+    for (const [, pending] of this.pendingMessages) {
+      if (pending.timeoutId) globalThis.clearTimeout(pending.timeoutId);
+      pending.reject(reason);
+    }
+    this.pendingMessages.clear();
+  }
+  async init() {
+    if (this.initPromise) return this.initPromise;
+    if (this.isInitializing) {
+      await new Promise((resolve) => globalThis.setTimeout(resolve, 100));
+      return this.init();
+    }
+    this.isInitializing = true;
+    this.initPromise = this.sendMessage("init", void 0, INIT_TIMEOUT_MS2);
+    try {
+      return await this.initPromise;
+    } catch (error) {
+      this.initPromise = null;
+      throw error;
+    } finally {
+      this.isInitializing = false;
+    }
+  }
+  async executeWithTracing(code, functionName, inputs, options, executionStyle = "function", language = "javascript") {
+    await this.init();
+    return this.executeWithTimeout(
+      () => this.sendMessage(
+        "execute-with-tracing",
+        {
+          code,
+          functionName,
+          inputs,
+          options,
+          executionStyle,
+          language
+        },
+        TRACING_TIMEOUT_MS2 + 2e3
+      ),
+      TRACING_TIMEOUT_MS2
+    );
+  }
+  async executeCode(code, functionName, inputs, executionStyle = "function", language = "javascript") {
+    await this.init();
+    return this.executeWithTimeout(
+      () => this.sendMessage(
+        "execute-code",
+        {
+          code,
+          functionName,
+          inputs,
+          executionStyle,
+          language
+        },
+        EXECUTION_TIMEOUT_MS2 + 2e3
+      ),
+      EXECUTION_TIMEOUT_MS2
+    );
+  }
+  async executeCodeInterviewMode(code, functionName, inputs, executionStyle = "function", language = "javascript") {
+    await this.init();
+    try {
+      const result = await this.executeWithTimeout(
+        () => this.sendMessage(
+          "execute-code-interview",
+          {
+            code,
+            functionName,
+            inputs,
+            executionStyle,
+            language
+          },
+          INTERVIEW_MODE_TIMEOUT_MS2 + 2e3
+        ),
+        INTERVIEW_MODE_TIMEOUT_MS2
+      );
+      if (!result.success && result.error) {
+        const normalized = result.error.toLowerCase();
+        const isTimeoutOrResourceLimit = normalized.includes("timed out") || normalized.includes("infinite loop") || normalized.includes("line-limit") || normalized.includes("single-line-limit") || normalized.includes("recursion-limit") || normalized.includes("trace-limit") || normalized.includes("line events") || normalized.includes("trace steps") || normalized.includes("call depth");
+        if (isTimeoutOrResourceLimit) {
+          return {
+            success: false,
+            output: null,
+            error: "Time Limit Exceeded",
+            consoleOutput: result.consoleOutput ?? []
+          };
+        }
+      }
+      return result;
+    } catch {
+      return {
+        success: false,
+        output: null,
+        error: "Time Limit Exceeded",
+        consoleOutput: []
+      };
+    }
+  }
+  terminate() {
+    this.terminateAndReset();
+  }
+};
+function isJavaScriptWorkerSupported() {
+  return typeof Worker !== "undefined";
+}
+export {
+  JavaScriptWorkerClient,
+  PyodideWorkerClient,
+  isJavaScriptWorkerSupported,
+  isWorkerSupported
+};
+//# sourceMappingURL=browser.js.map