@tracecode/harness 0.4.0

package/dist/browser.js

@@ -0,0 +1,1317 @@
+// packages/harness-browser/src/javascript-worker-client.ts
+var EXECUTION_TIMEOUT_MS = 7e3;
+var INTERVIEW_MODE_TIMEOUT_MS = 5e3;
+var TRACING_TIMEOUT_MS = 7e3;
+var INIT_TIMEOUT_MS = 1e4;
+var MESSAGE_TIMEOUT_MS = 12e3;
+var WORKER_READY_TIMEOUT_MS = 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_MS / 1e3)}s)`
+        );
+        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)));
+      });
+    });
+  }
+  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
+      });
+      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_MS);
+    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_MS + 2e3
+      ),
+      TRACING_TIMEOUT_MS
+    );
+  }
+  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_MS + 2e3
+      ),
+      EXECUTION_TIMEOUT_MS
+    );
+  }
+  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_MS + 2e3
+        ),
+        INTERVIEW_MODE_TIMEOUT_MS
+      );
+      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();
+  }
+};
+
+// packages/harness-core/src/trace-contract.ts
+var RUNTIME_TRACE_CONTRACT_SCHEMA_VERSION = "2026-03-07";
+var TRACE_EVENTS = /* @__PURE__ */ new Set([
+  "line",
+  "call",
+  "return",
+  "exception",
+  "timeout",
+  "stdout"
+]);
+var TRACE_ACCESS_KINDS = /* @__PURE__ */ new Set([
+  "indexed-read",
+  "indexed-write",
+  "cell-read",
+  "cell-write",
+  "mutating-call"
+]);
+function normalizeLineNumber(value, fallback = 1) {
+  if (typeof value !== "number" || !Number.isFinite(value)) return fallback;
+  const normalized = Math.floor(value);
+  return normalized > 0 ? normalized : fallback;
+}
+function normalizeOutputLineCount(value) {
+  if (typeof value !== "number" || !Number.isFinite(value)) return void 0;
+  const normalized = Math.floor(value);
+  return normalized >= 0 ? normalized : void 0;
+}
+function normalizeEvent(value) {
+  if (typeof value === "string" && TRACE_EVENTS.has(value)) {
+    return value;
+  }
+  return "line";
+}
+function normalizeAccessKind(value) {
+  if (typeof value === "string" && TRACE_ACCESS_KINDS.has(value)) {
+    return value;
+  }
+  return null;
+}
+function normalizeFunctionName(value) {
+  if (typeof value === "string" && value.length > 0) return value;
+  return "<module>";
+}
+function normalizeKind(value) {
+  if (value === "map" || value === "set" || value === "hashmap") {
+    return value;
+  }
+  return "hashmap";
+}
+function normalizeObjectKind(value) {
+  if (value === "hashmap" || value === "map" || value === "set" || value === "tree" || value === "linked-list" || value === "graph-adjacency") {
+    return value;
+  }
+  return null;
+}
+function normalizeScalar(value) {
+  if (value === null || value === void 0) return value;
+  if (typeof value === "string" || typeof value === "boolean") return value;
+  if (typeof value === "number") return Number.isFinite(value) ? value : String(value);
+  if (typeof value === "bigint") {
+    const asNumber = Number(value);
+    return Number.isSafeInteger(asNumber) ? asNumber : String(value);
+  }
+  if (typeof value === "function") return "<function>";
+  return null;
+}
+function normalizeUnknown(value, depth = 0, seen = /* @__PURE__ */ new WeakSet()) {
+  if (depth > 48) return "<max depth>";
+  const scalar = normalizeScalar(value);
+  if (scalar !== null || value === null || value === void 0) {
+    return scalar;
+  }
+  if (Array.isArray(value)) {
+    return value.map((item) => {
+      if (item === void 0) return null;
+      return normalizeUnknown(item, depth + 1, seen);
+    });
+  }
+  if (typeof value === "object" && value) {
+    if (seen.has(value)) return "<cycle>";
+    seen.add(value);
+    const normalized = {};
+    for (const key of Object.keys(value).sort()) {
+      const child = value[key];
+      if (child === void 0) continue;
+      normalized[key] = normalizeUnknown(child, depth + 1, seen);
+    }
+    seen.delete(value);
+    return normalized;
+  }
+  return String(value);
+}
+function normalizeAccesses(accesses) {
+  if (!Array.isArray(accesses) || accesses.length === 0) {
+    return void 0;
+  }
+  const normalized = accesses.map((access) => {
+    const variable = typeof access?.variable === "string" && access.variable.length > 0 ? access.variable : "";
+    const kind = normalizeAccessKind(access?.kind);
+    if (!variable || !kind) {
+      return null;
+    }
+    const indices = Array.isArray(access?.indices) ? access.indices.map(
+      (index) => typeof index === "number" && Number.isFinite(index) ? Math.floor(index) : null
+    ).filter((index) => index !== null) : void 0;
+    const pathDepth = access?.pathDepth === 1 || access?.pathDepth === 2 ? access.pathDepth : void 0;
+    const method = typeof access?.method === "string" && access.method.length > 0 ? access.method : void 0;
+    const payload = {
+      variable,
+      kind
+    };
+    if (indices && indices.length > 0) {
+      payload.indices = indices;
+    }
+    if (pathDepth !== void 0) {
+      payload.pathDepth = pathDepth;
+    }
+    if (method) {
+      payload.method = method;
+    }
+    return payload;
+  }).filter((access) => access !== null);
+  return normalized.length > 0 ? normalized : void 0;
+}
+function normalizeRecord(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return {};
+  return normalizeUnknown(value);
+}
+function normalizeCallStackFrame(frame) {
+  return {
+    function: normalizeFunctionName(frame?.function),
+    line: normalizeLineNumber(frame?.line, 1),
+    args: normalizeRecord(frame?.args)
+  };
+}
+function normalizeVisualizationPayload(payload) {
+  const hashMaps = Array.isArray(payload?.hashMaps) ? payload.hashMaps.map((entry) => ({
+    name: typeof entry?.name === "string" ? entry.name : "",
+    kind: normalizeKind(entry?.kind),
+    entries: Array.isArray(entry?.entries) ? entry.entries.map((item) => ({
+      key: normalizeUnknown(item?.key),
+      value: normalizeUnknown(item?.value),
+      ...item?.highlight ? { highlight: true } : {}
+    })) : [],
+    ...entry?.highlightedKey !== void 0 ? { highlightedKey: normalizeUnknown(entry.highlightedKey) } : {},
+    ...entry?.deletedKey !== void 0 ? { deletedKey: normalizeUnknown(entry.deletedKey) } : {}
+  })).sort((a, b) => `${a.name}:${a.kind}`.localeCompare(`${b.name}:${b.kind}`)) : [];
+  const objectKinds = payload?.objectKinds && typeof payload.objectKinds === "object" ? Object.fromEntries(
+    Object.entries(payload.objectKinds).filter(([name]) => typeof name === "string" && name.length > 0).map(([name, kind]) => [name, normalizeObjectKind(kind)]).filter((entry) => entry[1] !== null).sort((a, b) => a[0].localeCompare(b[0]))
+  ) : void 0;
+  if (hashMaps.length === 0 && (!objectKinds || Object.keys(objectKinds).length === 0)) {
+    return void 0;
+  }
+  return {
+    ...hashMaps.length > 0 ? { hashMaps } : {},
+    ...objectKinds && Object.keys(objectKinds).length > 0 ? { objectKinds } : {}
+  };
+}
+function normalizeTraceStep(step) {
+  const normalizedStdoutCount = normalizeOutputLineCount(step?.stdoutLineCount);
+  const normalizedVisualization = normalizeVisualizationPayload(step?.visualization);
+  const normalizedAccesses = normalizeAccesses(step?.accesses);
+  return {
+    event: normalizeEvent(step?.event),
+    line: normalizeLineNumber(step?.line, 1),
+    function: normalizeFunctionName(step?.function),
+    variables: normalizeRecord(step?.variables),
+    ...Array.isArray(step?.callStack) && step.callStack.length > 0 ? { callStack: step.callStack.map(normalizeCallStackFrame) } : {},
+    ...normalizedAccesses ? { accesses: normalizedAccesses } : {},
+    ...step?.returnValue !== void 0 ? { returnValue: normalizeUnknown(step.returnValue) } : {},
+    ...normalizedStdoutCount !== void 0 ? { stdoutLineCount: normalizedStdoutCount } : {},
+    ...normalizedVisualization ? { visualization: normalizedVisualization } : {}
+  };
+}
+function normalizeRuntimeTraceContract(language, result) {
+  const normalizedTrace = Array.isArray(result.trace) ? result.trace.map(normalizeTraceStep) : [];
+  const lineEventCount = typeof result.lineEventCount === "number" && Number.isFinite(result.lineEventCount) ? Math.floor(result.lineEventCount) : normalizedTrace.filter((step) => step.event === "line").length;
+  const normalizedConsole = Array.isArray(result.consoleOutput) ? result.consoleOutput.map((line) => String(line)) : [];
+  return {
+    schemaVersion: RUNTIME_TRACE_CONTRACT_SCHEMA_VERSION,
+    language,
+    success: Boolean(result.success),
+    ...Object.prototype.hasOwnProperty.call(result, "output") ? { output: normalizeUnknown(result.output) } : {},
+    ...typeof result.error === "string" && result.error.length > 0 ? { error: result.error } : {},
+    ...typeof result.errorLine === "number" && Number.isFinite(result.errorLine) ? { errorLine: Math.floor(result.errorLine) } : {},
+    consoleOutput: normalizedConsole,
+    trace: normalizedTrace,
+    ...result.traceLimitExceeded !== void 0 ? { traceLimitExceeded: Boolean(result.traceLimitExceeded) } : {},
+    ...typeof result.timeoutReason === "string" && result.timeoutReason.length > 0 ? { timeoutReason: result.timeoutReason } : {},
+    lineEventCount: Math.max(0, lineEventCount),
+    traceStepCount: normalizedTrace.length
+  };
+}
+
+// packages/harness-core/src/trace-adapters/shared.ts
+function denormalizeCallStackFrame(frame) {
+  return {
+    function: frame.function,
+    line: frame.line,
+    args: frame.args
+  };
+}
+function denormalizeTraceStep(step) {
+  return {
+    line: step.line,
+    event: step.event,
+    variables: step.variables,
+    function: step.function,
+    ...step.callStack ? { callStack: step.callStack.map(denormalizeCallStackFrame) } : {},
+    ...step.accesses ? { accesses: step.accesses } : {},
+    ...step.returnValue !== void 0 ? { returnValue: step.returnValue } : {},
+    ...step.stdoutLineCount !== void 0 ? { stdoutLineCount: step.stdoutLineCount } : {},
+    ...step.visualization ? { visualization: step.visualization } : {}
+  };
+}
+function adaptTraceExecutionResult(language, result) {
+  const normalized = normalizeRuntimeTraceContract(language, result);
+  const adaptedTrace = normalized.trace.map(denormalizeTraceStep);
+  return {
+    success: normalized.success,
+    ...Object.prototype.hasOwnProperty.call(normalized, "output") ? { output: normalized.output } : {},
+    ...normalized.error ? { error: normalized.error } : {},
+    ...normalized.errorLine !== void 0 ? { errorLine: normalized.errorLine } : {},
+    trace: adaptedTrace,
+    executionTimeMs: typeof result.executionTimeMs === "number" && Number.isFinite(result.executionTimeMs) ? result.executionTimeMs : 0,
+    consoleOutput: normalized.consoleOutput,
+    ...normalized.traceLimitExceeded !== void 0 ? { traceLimitExceeded: normalized.traceLimitExceeded } : {},
+    ...normalized.timeoutReason ? { timeoutReason: normalized.timeoutReason } : {},
+    lineEventCount: normalized.lineEventCount,
+    traceStepCount: adaptedTrace.length
+  };
+}
+
+// packages/harness-core/src/trace-adapters/javascript.ts
+function adaptJavaScriptTraceExecutionResult(language, result) {
+  return adaptTraceExecutionResult(language, result);
+}
+
+// packages/harness-browser/src/runtime-capability-guards.ts
+function isScriptRequest(functionName) {
+  if (functionName == null) return true;
+  return functionName.trim().length === 0;
+}
+function executionStyleLabel(executionStyle) {
+  if (executionStyle === "solution-method") return "solution-method";
+  if (executionStyle === "ops-class") return "ops-class";
+  return "function";
+}
+function isExecutionStyleSupported(profile, executionStyle) {
+  const styles = profile.capabilities.execution.styles;
+  if (executionStyle === "solution-method") return styles.solutionMethod;
+  if (executionStyle === "ops-class") return styles.opsClass;
+  return styles.function;
+}
+function describeRequest(request) {
+  if (request === "trace") return "tracing";
+  if (request === "interview") return "interview execution";
+  return "execution";
+}
+function assertRuntimeRequestSupported(profile, options) {
+  if (options.request === "trace" && !profile.capabilities.tracing.supported) {
+    throw new Error(`Runtime "${profile.language}" does not support tracing.`);
+  }
+  if (options.request === "interview" && !profile.capabilities.execution.styles.interviewMode) {
+    throw new Error(`Runtime "${profile.language}" does not support interview execution.`);
+  }
+  if (!isExecutionStyleSupported(profile, options.executionStyle)) {
+    throw new Error(
+      `Runtime "${profile.language}" does not support execution style "${executionStyleLabel(options.executionStyle)}".`
+    );
+  }
+  if (isScriptRequest(options.functionName) && !profile.capabilities.execution.styles.script) {
+    throw new Error(`Runtime "${profile.language}" does not support script mode ${describeRequest(options.request)}.`);
+  }
+}
+
+// packages/harness-browser/src/runtime-profiles.ts
+var PYTHON_RUNTIME_PROFILE = {
+  language: "python",
+  maturity: "stable",
+  capabilities: {
+    execution: {
+      styles: {
+        function: true,
+        solutionMethod: true,
+        opsClass: true,
+        script: true,
+        interviewMode: true
+      },
+      timeouts: {
+        clientTimeouts: true,
+        runtimeTimeouts: true
+      }
+    },
+    tracing: {
+      supported: true,
+      events: {
+        line: true,
+        call: true,
+        return: true,
+        exception: true,
+        stdout: true,
+        timeout: true
+      },
+      controls: {
+        maxTraceSteps: true,
+        maxLineEvents: true,
+        maxSingleLineHits: true,
+        minimalTrace: true
+      },
+      fidelity: {
+        preciseLineMapping: true,
+        stableFunctionNames: true,
+        callStack: true
+      }
+    },
+    diagnostics: {
+      compileErrors: false,
+      runtimeErrors: true,
+      mappedErrorLines: true,
+      stackTraces: false
+    },
+    structures: {
+      treeNodeRefs: true,
+      listNodeRefs: true,
+      mapSerialization: true,
+      setSerialization: true,
+      graphSerialization: true,
+      cycleReferences: true
+    },
+    visualization: {
+      runtimePayloads: true,
+      objectKinds: true,
+      hashMaps: true,
+      stepVisualization: true
+    }
+  }
+};
+var JAVASCRIPT_RUNTIME_PROFILE = {
+  language: "javascript",
+  maturity: "stable",
+  capabilities: {
+    execution: {
+      styles: {
+        function: true,
+        solutionMethod: true,
+        opsClass: true,
+        script: true,
+        interviewMode: true
+      },
+      timeouts: {
+        clientTimeouts: true,
+        runtimeTimeouts: false
+      }
+    },
+    tracing: {
+      supported: true,
+      events: {
+        line: true,
+        call: true,
+        return: true,
+        exception: true,
+        stdout: false,
+        timeout: true
+      },
+      controls: {
+        maxTraceSteps: true,
+        maxLineEvents: true,
+        maxSingleLineHits: true,
+        minimalTrace: true
+      },
+      fidelity: {
+        preciseLineMapping: true,
+        stableFunctionNames: true,
+        callStack: true
+      }
+    },
+    diagnostics: {
+      compileErrors: false,
+      runtimeErrors: true,
+      mappedErrorLines: false,
+      stackTraces: false
+    },
+    structures: {
+      treeNodeRefs: true,
+      listNodeRefs: true,
+      mapSerialization: true,
+      setSerialization: true,
+      graphSerialization: true,
+      cycleReferences: true
+    },
+    visualization: {
+      runtimePayloads: true,
+      objectKinds: true,
+      hashMaps: true,
+      stepVisualization: true
+    }
+  }
+};
+var TYPESCRIPT_RUNTIME_PROFILE = {
+  language: "typescript",
+  maturity: "stable",
+  capabilities: {
+    execution: {
+      styles: {
+        function: true,
+        solutionMethod: true,
+        opsClass: true,
+        script: true,
+        interviewMode: true
+      },
+      timeouts: {
+        clientTimeouts: true,
+        runtimeTimeouts: false
+      }
+    },
+    tracing: {
+      supported: true,
+      events: {
+        line: true,
+        call: true,
+        return: true,
+        exception: true,
+        stdout: false,
+        timeout: true
+      },
+      controls: {
+        maxTraceSteps: true,
+        maxLineEvents: true,
+        maxSingleLineHits: true,
+        minimalTrace: true
+      },
+      fidelity: {
+        preciseLineMapping: true,
+        stableFunctionNames: true,
+        callStack: true
+      }
+    },
+    diagnostics: {
+      compileErrors: true,
+      runtimeErrors: true,
+      mappedErrorLines: true,
+      stackTraces: false
+    },
+    structures: {
+      treeNodeRefs: true,
+      listNodeRefs: true,
+      mapSerialization: true,
+      setSerialization: true,
+      graphSerialization: true,
+      cycleReferences: true
+    },
+    visualization: {
+      runtimePayloads: true,
+      objectKinds: true,
+      hashMaps: true,
+      stepVisualization: true
+    }
+  }
+};
+var LANGUAGE_RUNTIME_PROFILES = {
+  python: PYTHON_RUNTIME_PROFILE,
+  javascript: JAVASCRIPT_RUNTIME_PROFILE,
+  typescript: TYPESCRIPT_RUNTIME_PROFILE
+};
+var SUPPORTED_LANGUAGES = Object.freeze(
+  Object.keys(LANGUAGE_RUNTIME_PROFILES)
+);
+function getLanguageRuntimeProfile(language) {
+  const profile = LANGUAGE_RUNTIME_PROFILES[language];
+  if (!profile) {
+    throw new Error(`Runtime profile for language "${language}" is not implemented yet.`);
+  }
+  return profile;
+}
+function getSupportedLanguageProfiles() {
+  return SUPPORTED_LANGUAGES.map((language) => LANGUAGE_RUNTIME_PROFILES[language]);
+}
+function isLanguageSupported(language) {
+  return SUPPORTED_LANGUAGES.includes(language);
+}
+
+// packages/harness-browser/src/javascript-runtime-client.ts
+var JavaScriptRuntimeClient = class {
+  constructor(runtimeLanguage, workerClient) {
+    this.runtimeLanguage = runtimeLanguage;
+    this.workerClient = workerClient;
+  }
+  async init() {
+    return this.workerClient.init();
+  }
+  async executeWithTracing(code, functionName, inputs, options, executionStyle = "function") {
+    assertRuntimeRequestSupported(getLanguageRuntimeProfile(this.runtimeLanguage), {
+      request: "trace",
+      executionStyle,
+      functionName
+    });
+    const rawResult = await this.workerClient.executeWithTracing(
+      code,
+      functionName,
+      inputs,
+      options,
+      executionStyle,
+      this.runtimeLanguage
+    );
+    return adaptJavaScriptTraceExecutionResult(this.runtimeLanguage, rawResult);
+  }
+  async executeCode(code, functionName, inputs, executionStyle = "function") {
+    assertRuntimeRequestSupported(getLanguageRuntimeProfile(this.runtimeLanguage), {
+      request: "execute",
+      executionStyle,
+      functionName
+    });
+    return this.workerClient.executeCode(
+      code,
+      functionName,
+      inputs,
+      executionStyle,
+      this.runtimeLanguage
+    );
+  }
+  async executeCodeInterviewMode(code, functionName, inputs, executionStyle = "function") {
+    assertRuntimeRequestSupported(getLanguageRuntimeProfile(this.runtimeLanguage), {
+      request: "interview",
+      executionStyle,
+      functionName
+    });
+    return this.workerClient.executeCodeInterviewMode(
+      code,
+      functionName,
+      inputs,
+      executionStyle,
+      this.runtimeLanguage
+    );
+  }
+};
+function createJavaScriptRuntimeClient(runtimeLanguage, workerClient) {
+  return new JavaScriptRuntimeClient(runtimeLanguage, workerClient);
+}
+
+// packages/harness-browser/src/pyodide-worker-client.ts
+var EXECUTION_TIMEOUT_MS2 = 1e4;
+var INTERVIEW_MODE_TIMEOUT_MS2 = 5e3;
+var TRACING_TIMEOUT_MS2 = 3e4;
+var INIT_TIMEOUT_MS2 = 12e4;
+var MESSAGE_TIMEOUT_MS2 = 2e4;
+var WORKER_READY_TIMEOUT_MS2 = 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_MS2 / 1e3)}s)`
+        );
+        if (this.debug) {
+          console.warn("[PyodideWorkerClient] worker-ready timeout", { timeoutMs: WORKER_READY_TIMEOUT_MS2 });
+        }
+        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)));
+      });
+    });
+  }
+  /**
+   * Send a message to the worker and wait for a response
+   */
+  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
+      });
+      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_MS2) {
+    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_MS2);
+      } 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_MS2);
+      }
+    })();
+    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_MS2 + 5e3),
+        // Message timeout slightly longer than execution timeout
+        TRACING_TIMEOUT_MS2
+      );
+    } 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_MS2,
+          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_MS2 + 5e3),
+      EXECUTION_TIMEOUT_MS2
+    );
+  }
+  /**
+   * 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_MS2 + 2e3),
+        INTERVIEW_MODE_TIMEOUT_MS2
+      );
+      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();
+  }
+};
+
+// packages/harness-core/src/trace-adapters/python.ts
+function adaptPythonTraceExecutionResult(result) {
+  return adaptTraceExecutionResult("python", result);
+}
+
+// packages/harness-browser/src/python-runtime-client.ts
+var PythonRuntimeClient = class {
+  constructor(workerClient) {
+    this.workerClient = workerClient;
+  }
+  async init() {
+    return this.workerClient.init();
+  }
+  async executeWithTracing(code, functionName, inputs, options, executionStyle = "function") {
+    assertRuntimeRequestSupported(getLanguageRuntimeProfile("python"), {
+      request: "trace",
+      executionStyle,
+      functionName
+    });
+    const rawResult = await this.workerClient.executeWithTracing(
+      code,
+      functionName,
+      inputs,
+      options,
+      executionStyle
+    );
+    return adaptPythonTraceExecutionResult(rawResult);
+  }
+  async executeCode(code, functionName, inputs, executionStyle = "function") {
+    assertRuntimeRequestSupported(getLanguageRuntimeProfile("python"), {
+      request: "execute",
+      executionStyle,
+      functionName
+    });
+    return this.workerClient.executeCode(
+      code,
+      functionName,
+      inputs,
+      executionStyle
+    );
+  }
+  async executeCodeInterviewMode(code, functionName, inputs, executionStyle = "function") {
+    assertRuntimeRequestSupported(getLanguageRuntimeProfile("python"), {
+      request: "interview",
+      executionStyle,
+      functionName
+    });
+    return this.workerClient.executeCodeInterviewMode(
+      code,
+      functionName,
+      inputs,
+      executionStyle
+    );
+  }
+};
+function createPythonRuntimeClient(workerClient) {
+  return new PythonRuntimeClient(workerClient);
+}
+
+// packages/harness-browser/src/runtime-assets.ts
+var DEFAULT_ASSET_BASE_URL = "/workers";
+var DEFAULT_BROWSER_HARNESS_ASSET_RELATIVE_PATHS = Object.freeze({
+  pythonWorker: "pyodide-worker.js",
+  pythonRuntimeCore: "pyodide/runtime-core.js",
+  pythonSnippets: "generated-python-harness-snippets.js",
+  javascriptWorker: "javascript-worker.js",
+  typescriptCompiler: "vendor/typescript.js"
+});
+function isExplicitAssetPath(pathname) {
+  return pathname.startsWith("/") || pathname.startsWith("./") || pathname.startsWith("../") || pathname.startsWith("http://") || pathname.startsWith("https://") || pathname.startsWith("data:") || pathname.startsWith("blob:");
+}
+function stripTrailingSlash(value) {
+  return value.replace(/\/+$/, "");
+}
+function trimLeadingSlash(value) {
+  return value.replace(/^\/+/, "");
+}
+function resolveAssetPath(baseUrl, pathname) {
+  if (isExplicitAssetPath(pathname)) {
+    return pathname;
+  }
+  const normalizedBase = stripTrailingSlash(baseUrl || DEFAULT_ASSET_BASE_URL);
+  const normalizedPath = trimLeadingSlash(pathname);
+  return `${normalizedBase}/${normalizedPath}`;
+}
+function resolveBrowserHarnessAssets(options = {}) {
+  const assetBaseUrl = options.assetBaseUrl ?? DEFAULT_ASSET_BASE_URL;
+  const assets = options.assets ?? {};
+  return {
+    pythonWorker: resolveAssetPath(assetBaseUrl, assets.pythonWorker ?? DEFAULT_BROWSER_HARNESS_ASSET_RELATIVE_PATHS.pythonWorker),
+    pythonRuntimeCore: resolveAssetPath(
+      assetBaseUrl,
+      assets.pythonRuntimeCore ?? DEFAULT_BROWSER_HARNESS_ASSET_RELATIVE_PATHS.pythonRuntimeCore
+    ),
+    pythonSnippets: resolveAssetPath(assetBaseUrl, assets.pythonSnippets ?? DEFAULT_BROWSER_HARNESS_ASSET_RELATIVE_PATHS.pythonSnippets),
+    javascriptWorker: resolveAssetPath(
+      assetBaseUrl,
+      assets.javascriptWorker ?? DEFAULT_BROWSER_HARNESS_ASSET_RELATIVE_PATHS.javascriptWorker
+    ),
+    typescriptCompiler: resolveAssetPath(
+      assetBaseUrl,
+      assets.typescriptCompiler ?? DEFAULT_BROWSER_HARNESS_ASSET_RELATIVE_PATHS.typescriptCompiler
+    )
+  };
+}
+
+// packages/harness-browser/src/browser-harness.ts
+var BrowserHarnessRuntime = class {
+  assets;
+  supportedLanguages = SUPPORTED_LANGUAGES;
+  pythonWorkerClient;
+  javaScriptWorkerClient;
+  clients;
+  constructor(options = {}) {
+    this.assets = resolveBrowserHarnessAssets(options);
+    this.pythonWorkerClient = new PyodideWorkerClient({
+      workerUrl: this.assets.pythonWorker,
+      debug: options.debug
+    });
+    this.javaScriptWorkerClient = new JavaScriptWorkerClient({
+      workerUrl: this.assets.javascriptWorker,
+      debug: options.debug
+    });
+    this.clients = {
+      python: createPythonRuntimeClient(this.pythonWorkerClient),
+      javascript: createJavaScriptRuntimeClient("javascript", this.javaScriptWorkerClient),
+      typescript: createJavaScriptRuntimeClient("typescript", this.javaScriptWorkerClient)
+    };
+  }
+  getClient(language) {
+    const client = this.clients[language];
+    if (!client) {
+      throw new Error(`Runtime for language "${language}" is not implemented yet.`);
+    }
+    return client;
+  }
+  getProfile(language) {
+    return getLanguageRuntimeProfile(language);
+  }
+  getSupportedLanguageProfiles() {
+    return getSupportedLanguageProfiles();
+  }
+  isLanguageSupported(language) {
+    return isLanguageSupported(language);
+  }
+  disposeLanguage(language) {
+    if (language === "python") {
+      this.pythonWorkerClient.terminate();
+      return;
+    }
+    this.javaScriptWorkerClient.terminate();
+  }
+  dispose() {
+    this.pythonWorkerClient.terminate();
+    this.javaScriptWorkerClient.terminate();
+  }
+};
+function createBrowserHarness(options = {}) {
+  return new BrowserHarnessRuntime(options);
+}
+export {
+  DEFAULT_BROWSER_HARNESS_ASSET_RELATIVE_PATHS,
+  LANGUAGE_RUNTIME_PROFILES,
+  SUPPORTED_LANGUAGES,
+  assertRuntimeRequestSupported,
+  createBrowserHarness,
+  getLanguageRuntimeProfile,
+  getSupportedLanguageProfiles,
+  isLanguageSupported,
+  resolveBrowserHarnessAssets
+};
+//# sourceMappingURL=browser.js.map