@tracecode/harness 0.4.0

package/dist/index.js

@@ -0,0 +1,2538 @@
+// 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
+  };
+}
+function stableStringifyRuntimeTraceContract(value) {
+  return JSON.stringify(normalizeUnknown(value), null, 2);
+}
+
+// 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/python.ts
+function adaptPythonTraceExecutionResult(result) {
+  return adaptTraceExecutionResult("python", result);
+}
+
+// packages/harness-core/src/trace-adapters/javascript.ts
+function adaptJavaScriptTraceExecutionResult(language, result) {
+  return adaptTraceExecutionResult(language, result);
+}
+
+// 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-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-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);
+}
+
+// packages/harness-python/src/generated/python-harness-snippets.ts
+function toPythonLiteral(value) {
+  if (value === null || value === void 0) {
+    return "None";
+  }
+  if (typeof value === "boolean") {
+    return value ? "True" : "False";
+  }
+  if (typeof value === "number") {
+    return String(value);
+  }
+  if (typeof value === "string") {
+    return JSON.stringify(value);
+  }
+  if (Array.isArray(value)) {
+    return "[" + value.map(toPythonLiteral).join(", ") + "]";
+  }
+  if (typeof value === "object") {
+    const entries = Object.entries(value).map(([k, v]) => `${JSON.stringify(k)}: ${toPythonLiteral(v)}`).join(", ");
+    return "{" + entries + "}";
+  }
+  return JSON.stringify(value);
+}
+var PYTHON_CLASS_DEFINITIONS = `
+class TreeNode:
+    def __init__(self, val=0, left=None, right=None):
+        self.val = val
+        self.value = val
+        self.left = left
+        self.right = right
+    def __getitem__(self, key):
+        if key == 'val': return getattr(self, 'val', getattr(self, 'value', None))
+        if key == 'value': return getattr(self, 'value', getattr(self, 'val', None))
+        if key == 'left': return self.left
+        if key == 'right': return self.right
+        raise KeyError(key)
+    def get(self, key, default=None):
+        if key == 'val': return getattr(self, 'val', getattr(self, 'value', default))
+        if key == 'value': return getattr(self, 'value', getattr(self, 'val', default))
+        if key == 'left': return self.left
+        if key == 'right': return self.right
+        return default
+    def __repr__(self):
+        return f"TreeNode({getattr(self, 'val', getattr(self, 'value', None))})"
+
+class ListNode:
+    def __init__(self, val=0, next=None):
+        self.val = val
+        self.value = val
+        self.next = next
+    def __getitem__(self, key):
+        if key == 'val': return getattr(self, 'val', getattr(self, 'value', None))
+        if key == 'value': return getattr(self, 'value', getattr(self, 'val', None))
+        if key == 'next': return self.next
+        raise KeyError(key)
+    def get(self, key, default=None):
+        if key == 'val': return getattr(self, 'val', getattr(self, 'value', default))
+        if key == 'value': return getattr(self, 'value', getattr(self, 'val', default))
+        if key == 'next': return self.next
+        return default
+    def __repr__(self):
+        return f"ListNode({getattr(self, 'val', getattr(self, 'value', None))})"
+`;
+var PYTHON_CONVERSION_HELPERS = "\ndef _ensure_node_value_aliases(node):\n    if node is None:\n        return node\n    try:\n        has_val = hasattr(node, 'val')\n        has_value = hasattr(node, 'value')\n        if has_value and not has_val:\n            try:\n                setattr(node, 'val', getattr(node, 'value'))\n            except Exception:\n                pass\n        elif has_val and not has_value:\n            try:\n                setattr(node, 'value', getattr(node, 'val'))\n            except Exception:\n                pass\n    except Exception:\n        pass\n    return node\n\ndef _dict_to_tree(d):\n    if d is None:\n        return None\n    if not isinstance(d, dict):\n        return d\n    if 'val' not in d and 'value' not in d:\n        return d\n    node = TreeNode(d.get('val', d.get('value', 0)))\n    _ensure_node_value_aliases(node)\n    node.left = _dict_to_tree(d.get('left'))\n    node.right = _dict_to_tree(d.get('right'))\n    return node\n\ndef _dict_to_list(d, _refs=None):\n    if _refs is None:\n        _refs = {}\n    if d is None:\n        return None\n    if not isinstance(d, dict):\n        return d\n    if '__ref__' in d:\n        return _refs.get(d.get('__ref__'))\n    if 'val' not in d and 'value' not in d:\n        return d\n    node = ListNode(d.get('val', d.get('value', 0)))\n    _ensure_node_value_aliases(node)\n    node_id = d.get('__id__')\n    if isinstance(node_id, str) and node_id:\n        _refs[node_id] = node\n    node.next = _dict_to_list(d.get('next'), _refs)\n    return node\n";
+var PYTHON_TRACE_SERIALIZE_FUNCTION = `
+# Sentinel to mark skipped values (functions, etc.) - distinct from None
+_SKIP_SENTINEL = "__TRACECODE_SKIP__"
+_MAX_SERIALIZE_DEPTH = 48
+
+def _serialize(obj, depth=0, node_refs=None):
+    if node_refs is None:
+        node_refs = {}
+    if isinstance(obj, (bool, int, str, type(None))):
+        return obj
+    elif isinstance(obj, float):
+        if not math.isfinite(obj):
+            if math.isnan(obj):
+                return "NaN"
+            return "Infinity" if obj > 0 else "-Infinity"
+        return obj
+    if depth > _MAX_SERIALIZE_DEPTH:
+        return "<max depth>"
+    elif isinstance(obj, (list, tuple)):
+        return [_serialize(x, depth + 1, node_refs) for x in obj]
+    elif getattr(obj, '__class__', None) and getattr(obj.__class__, '__name__', '') == 'deque':
+        return [_serialize(x, depth + 1, node_refs) for x in obj]
+    elif isinstance(obj, dict):
+        return {str(k): _serialize(v, depth + 1, node_refs) for k, v in obj.items()}
+    elif isinstance(obj, set):
+        # Use try/except for sorting to handle heterogeneous sets
+        try:
+            sorted_vals = sorted([_serialize(x, depth + 1, node_refs) for x in obj])
+        except TypeError:
+            sorted_vals = [_serialize(x, depth + 1, node_refs) for x in obj]
+        return {"__type__": "set", "values": sorted_vals}
+    elif (hasattr(obj, 'val') or hasattr(obj, 'value')) and (hasattr(obj, 'left') or hasattr(obj, 'right')):
+        obj_ref = id(obj)
+        if obj_ref in node_refs:
+            return {"__ref__": node_refs[obj_ref]}
+        node_id = f"tree-{obj_ref}"
+        node_refs[obj_ref] = node_id
+        result = {
+            "__type__": "TreeNode",
+            "__id__": node_id,
+            "val": _serialize(getattr(obj, 'val', getattr(obj, 'value', None)), depth + 1, node_refs),
+        }
+        if hasattr(obj, 'left'):
+            result["left"] = _serialize(obj.left, depth + 1, node_refs)
+        if hasattr(obj, 'right'):
+            result["right"] = _serialize(obj.right, depth + 1, node_refs)
+        return result
+    elif (hasattr(obj, 'val') or hasattr(obj, 'value')) and hasattr(obj, 'next'):
+        obj_ref = id(obj)
+        if obj_ref in node_refs:
+            return {"__ref__": node_refs[obj_ref]}
+        node_id = f"list-{obj_ref}"
+        node_refs[obj_ref] = node_id
+        result = {
+            "__type__": "ListNode",
+            "__id__": node_id,
+            "val": _serialize(getattr(obj, 'val', getattr(obj, 'value', None)), depth + 1, node_refs),
+        }
+        result["next"] = _serialize(obj.next, depth + 1, node_refs)
+        return result
+    elif callable(obj):
+        # Skip functions entirely - return sentinel
+        return _SKIP_SENTINEL
+    else:
+        repr_str = repr(obj)
+        # Filter out function-like representations (e.g., <function foo at 0x...>)
+        if repr_str.startswith('<') and repr_str.endswith('>'):
+            return _SKIP_SENTINEL
+        return repr_str
+`;
+var PYTHON_EXECUTE_SERIALIZE_FUNCTION = `
+_MAX_SERIALIZE_DEPTH = 48
+
+def _serialize(obj, depth=0):
+    if isinstance(obj, (bool, int, str, type(None))):
+        return obj
+    elif isinstance(obj, float):
+        if not math.isfinite(obj):
+            if math.isnan(obj):
+                return "NaN"
+            return "Infinity" if obj > 0 else "-Infinity"
+        return obj
+    if depth > _MAX_SERIALIZE_DEPTH:
+        return "<max depth>"
+    elif isinstance(obj, (list, tuple)):
+        return [_serialize(x, depth + 1) for x in obj]
+    elif getattr(obj, '__class__', None) and getattr(obj.__class__, '__name__', '') == 'deque':
+        return [_serialize(x, depth + 1) for x in obj]
+    elif isinstance(obj, dict):
+        return {str(k): _serialize(v, depth + 1) for k, v in obj.items()}
+    elif isinstance(obj, set):
+        try:
+            return {"__type__": "set", "values": sorted([_serialize(x, depth + 1) for x in obj])}
+        except TypeError:
+            return {"__type__": "set", "values": [_serialize(x, depth + 1) for x in obj]}
+    elif (hasattr(obj, 'val') or hasattr(obj, 'value')) and (hasattr(obj, 'left') or hasattr(obj, 'right')):
+        result = {"__type__": "TreeNode", "val": _serialize(getattr(obj, 'val', getattr(obj, 'value', None)), depth + 1)}
+        if hasattr(obj, 'left'):
+            result["left"] = _serialize(obj.left, depth + 1)
+        if hasattr(obj, 'right'):
+            result["right"] = _serialize(obj.right, depth + 1)
+        return result
+    elif (hasattr(obj, 'val') or hasattr(obj, 'value')) and hasattr(obj, 'next'):
+        result = {"__type__": "ListNode", "val": _serialize(getattr(obj, 'val', getattr(obj, 'value', None)), depth + 1)}
+        result["next"] = _serialize(obj.next, depth + 1)
+        return result
+    elif callable(obj):
+        return None
+    else:
+        repr_str = repr(obj)
+        if repr_str.startswith('<') and repr_str.endswith('>'):
+            return None
+        return repr_str
+`;
+var PYTHON_PRACTICE_MATERIALIZE_SERIALIZE_FUNCTION = `
+def _serialize(obj, depth=0, state=None):
+    if state is None:
+        state = {"nodes": 0, "seen": set()}
+    if depth > 64:
+        return "__MAX_DEPTH__"
+    if isinstance(obj, (int, float, str, bool, type(None))):
+        return obj
+
+    state["nodes"] += 1
+    if state["nodes"] > 600:
+        return "__MAX_NODES__"
+
+    if isinstance(obj, (list, tuple)):
+        return [_serialize(x, depth + 1, state) for x in obj]
+    elif isinstance(obj, dict):
+        return {str(k): _serialize(v, depth + 1, state) for k, v in obj.items()}
+    elif isinstance(obj, set):
+        serialized = [_serialize(x, depth + 1, state) for x in obj]
+        try:
+            serialized = sorted(serialized)
+        except TypeError:
+            pass
+        return {"__type__": "set", "values": serialized}
+    elif (hasattr(obj, 'val') or hasattr(obj, 'value')) and (hasattr(obj, 'left') or hasattr(obj, 'right')):
+        obj_id = id(obj)
+        if obj_id in state["seen"]:
+            return "__CYCLE__"
+        state["seen"].add(obj_id)
+        result = {"__type__": "TreeNode", "val": _serialize(getattr(obj, 'val', getattr(obj, 'value', None)), depth + 1, state)}
+        if hasattr(obj, 'left'):
+            result["left"] = _serialize(obj.left, depth + 1, state)
+        if hasattr(obj, 'right'):
+            result["right"] = _serialize(obj.right, depth + 1, state)
+        state["seen"].remove(obj_id)
+        return result
+    elif (hasattr(obj, 'val') or hasattr(obj, 'value')) and hasattr(obj, 'next'):
+        obj_id = id(obj)
+        if obj_id in state["seen"]:
+            return "__CYCLE__"
+        state["seen"].add(obj_id)
+        result = {"__type__": "ListNode", "val": _serialize(getattr(obj, 'val', getattr(obj, 'value', None)), depth + 1, state)}
+        result["next"] = _serialize(obj.next, depth + 1, state)
+        state["seen"].remove(obj_id)
+        return result
+    else:
+        return repr(obj)
+`;
+var PYTHON_INTERVIEW_MATERIALIZE_SERIALIZE_FUNCTION = `
+def _serialize(obj, depth=0):
+    if depth > 10:
+        return "<max depth>"
+    if isinstance(obj, (int, float, str, bool, type(None))):
+        return obj
+    elif isinstance(obj, (list, tuple)):
+        return [_serialize(x, depth + 1) for x in obj]
+    elif isinstance(obj, dict):
+        return {str(k): _serialize(v, depth + 1) for k, v in obj.items()}
+    elif isinstance(obj, set):
+        try:
+            return {"__type__": "set", "values": sorted([_serialize(x, depth + 1) for x in obj])}
+        except TypeError:
+            return {"__type__": "set", "values": [_serialize(x, depth + 1) for x in obj]}
+    elif hasattr(obj, 'val') and (hasattr(obj, 'left') or hasattr(obj, 'right')):
+        result = {"__type__": "TreeNode", "val": _serialize(getattr(obj, 'val', None), depth + 1)}
+        if hasattr(obj, 'left'):
+            result["left"] = _serialize(obj.left, depth + 1)
+        if hasattr(obj, 'right'):
+            result["right"] = _serialize(obj.right, depth + 1)
+        return result
+    elif hasattr(obj, 'val') and hasattr(obj, 'next'):
+        result = {"__type__": "ListNode", "val": _serialize(getattr(obj, 'val', None), depth + 1)}
+        result["next"] = _serialize(obj.next, depth + 1)
+        return result
+    else:
+        return repr(obj)
+`;
+var PYTHON_SERIALIZE_FUNCTION = `
+_MAX_SERIALIZE_DEPTH = 48
+
+def _serialize(obj, depth=0):
+    if isinstance(obj, (bool, int, str, type(None))):
+        return obj
+    elif isinstance(obj, float):
+        if not math.isfinite(obj):
+            if math.isnan(obj):
+                return "NaN"
+            return "Infinity" if obj > 0 else "-Infinity"
+        return obj
+    if depth > _MAX_SERIALIZE_DEPTH:
+        return "<max depth>"
+    elif isinstance(obj, (list, tuple)):
+        return [_serialize(x, depth + 1) for x in obj]
+    elif getattr(obj, '__class__', None) and getattr(obj.__class__, '__name__', '') == 'deque':
+        return [_serialize(x, depth + 1) for x in obj]
+    elif isinstance(obj, dict):
+        return {str(k): _serialize(v, depth + 1) for k, v in obj.items()}
+    elif isinstance(obj, set):
+        try:
+            return {"__type__": "set", "values": sorted([_serialize(x, depth + 1) for x in obj])}
+        except TypeError:
+            return {"__type__": "set", "values": [_serialize(x, depth + 1) for x in obj]}
+    elif (hasattr(obj, 'val') or hasattr(obj, 'value')) and (hasattr(obj, 'left') or hasattr(obj, 'right')):
+        result = {"__type__": "TreeNode", "val": _serialize(getattr(obj, 'val', getattr(obj, 'value', None)), depth + 1)}
+        if hasattr(obj, 'left'):
+            result["left"] = _serialize(obj.left, depth + 1)
+        if hasattr(obj, 'right'):
+            result["right"] = _serialize(obj.right, depth + 1)
+        return result
+    elif (hasattr(obj, 'val') or hasattr(obj, 'value')) and hasattr(obj, 'next'):
+        result = {"__type__": "ListNode", "val": _serialize(getattr(obj, 'val', getattr(obj, 'value', None)), depth + 1)}
+        result["next"] = _serialize(obj.next, depth + 1)
+        return result
+    elif callable(obj):
+        return None
+    else:
+        repr_str = repr(obj)
+        if repr_str.startswith('<') and repr_str.endswith('>'):
+            return None
+        return repr_str
+`;
+
+// packages/harness-python/src/python-harness.ts
+function identifyConversions(inputs) {
+  const treeKeys = [];
+  const listKeys = [];
+  for (const [key, value] of Object.entries(inputs)) {
+    if (value && typeof value === "object" && !Array.isArray(value) && ("val" in value || "value" in value)) {
+      const obj = value;
+      const hasLeft = "left" in obj;
+      const hasRight = "right" in obj;
+      const hasNext = "next" in obj;
+      if (hasLeft || hasRight) {
+        treeKeys.push(key);
+      } else if (hasNext) {
+        listKeys.push(key);
+      } else {
+        treeKeys.push(key);
+      }
+    }
+  }
+  return { treeKeys, listKeys };
+}
+function generateConversionCode(inputs) {
+  const { treeKeys, listKeys } = identifyConversions(inputs);
+  const lines = [];
+  for (const key of treeKeys) {
+    lines.push(`${key} = _dict_to_tree(${key})`);
+  }
+  for (const key of listKeys) {
+    lines.push(`${key} = _dict_to_list(${key})`);
+  }
+  return lines.join("\n");
+}
+function generateInputSetup(inputs) {
+  return Object.entries(inputs).map(([key, value]) => `${key} = ${toPythonLiteral(value)}`).join("\n");
+}
+function generateSolutionScript(solutionCode, functionName, inputs) {
+  const inputSetup = generateInputSetup(inputs);
+  const conversionCode = generateConversionCode(inputs);
+  const paramList = Object.keys(inputs).map((key) => `${key}=${key}`).join(", ");
+  return `
+import json
+import sys
+
+${PYTHON_CLASS_DEFINITIONS}
+
+${PYTHON_CONVERSION_HELPERS}
+
+${PYTHON_SERIALIZE_FUNCTION}
+
+# Solution code
+${solutionCode}
+
+# Set up inputs
+${inputSetup}
+
+# Convert tree/list inputs
+${conversionCode}
+
+# Run the function
+try:
+    _result = ${functionName}(${paramList})
+    print(json.dumps({"success": True, "output": _serialize(_result)}))
+except Exception as e:
+    print(json.dumps({"success": False, "error": f"{type(e).__name__}: {str(e)}"}))
+`;
+}
+
+// packages/harness-python/src/python-harness-template.ts
+function templateToPythonLiteral(value) {
+  if (value === null || value === void 0) {
+    return "None";
+  }
+  if (typeof value === "boolean") {
+    return value ? "True" : "False";
+  }
+  if (typeof value === "number") {
+    return String(value);
+  }
+  if (typeof value === "string") {
+    return JSON.stringify(value);
+  }
+  if (Array.isArray(value)) {
+    return "[" + value.map(templateToPythonLiteral).join(", ") + "]";
+  }
+  if (typeof value === "object") {
+    const entries = Object.entries(value).map(([k, v]) => `${JSON.stringify(k)}: ${templateToPythonLiteral(v)}`).join(", ");
+    return "{" + entries + "}";
+  }
+  return JSON.stringify(value);
+}
+var TEMPLATE_PYTHON_CLASS_DEFINITIONS = `
+class TreeNode:
+    def __init__(self, val=0, left=None, right=None):
+        self.val = val
+        self.value = val
+        self.left = left
+        self.right = right
+    def __getitem__(self, key):
+        if key == 'val': return getattr(self, 'val', getattr(self, 'value', None))
+        if key == 'value': return getattr(self, 'value', getattr(self, 'val', None))
+        if key == 'left': return self.left
+        if key == 'right': return self.right
+        raise KeyError(key)
+    def get(self, key, default=None):
+        if key == 'val': return getattr(self, 'val', getattr(self, 'value', default))
+        if key == 'value': return getattr(self, 'value', getattr(self, 'val', default))
+        if key == 'left': return self.left
+        if key == 'right': return self.right
+        return default
+    def __repr__(self):
+        return f"TreeNode({getattr(self, 'val', getattr(self, 'value', None))})"
+
+class ListNode:
+    def __init__(self, val=0, next=None):
+        self.val = val
+        self.value = val
+        self.next = next
+    def __getitem__(self, key):
+        if key == 'val': return getattr(self, 'val', getattr(self, 'value', None))
+        if key == 'value': return getattr(self, 'value', getattr(self, 'val', None))
+        if key == 'next': return self.next
+        raise KeyError(key)
+    def get(self, key, default=None):
+        if key == 'val': return getattr(self, 'val', getattr(self, 'value', default))
+        if key == 'value': return getattr(self, 'value', getattr(self, 'val', default))
+        if key == 'next': return self.next
+        return default
+    def __repr__(self):
+        return f"ListNode({getattr(self, 'val', getattr(self, 'value', None))})"
+`;
+var TEMPLATE_PYTHON_CONVERSION_HELPERS = `
+def _ensure_node_value_aliases(node):
+    if node is None:
+        return node
+    try:
+        has_val = hasattr(node, 'val')
+        has_value = hasattr(node, 'value')
+        if has_value and not has_val:
+            try:
+                setattr(node, 'val', getattr(node, 'value'))
+            except Exception:
+                pass
+        elif has_val and not has_value:
+            try:
+                setattr(node, 'value', getattr(node, 'val'))
+            except Exception:
+                pass
+    except Exception:
+        pass
+    return node
+
+def _dict_to_tree(d):
+    if d is None:
+        return None
+    if not isinstance(d, dict):
+        return d
+    if 'val' not in d and 'value' not in d:
+        return d
+    node = TreeNode(d.get('val', d.get('value', 0)))
+    _ensure_node_value_aliases(node)
+    node.left = _dict_to_tree(d.get('left'))
+    node.right = _dict_to_tree(d.get('right'))
+    return node
+
+def _dict_to_list(d, _refs=None):
+    if _refs is None:
+        _refs = {}
+    if d is None:
+        return None
+    if not isinstance(d, dict):
+        return d
+    if '__ref__' in d:
+        return _refs.get(d.get('__ref__'))
+    if 'val' not in d and 'value' not in d:
+        return d
+    node = ListNode(d.get('val', d.get('value', 0)))
+    _ensure_node_value_aliases(node)
+    node_id = d.get('__id__')
+    if isinstance(node_id, str) and node_id:
+        _refs[node_id] = node
+    node.next = _dict_to_list(d.get('next'), _refs)
+    return node
+`;
+var TEMPLATE_PYTHON_TRACE_SERIALIZE_FUNCTION = `
+# Sentinel to mark skipped values (functions, etc.) - distinct from None
+_SKIP_SENTINEL = "__TRACECODE_SKIP__"
+_MAX_SERIALIZE_DEPTH = 48
+
+def _serialize(obj, depth=0, node_refs=None):
+    if node_refs is None:
+        node_refs = {}
+    if isinstance(obj, (bool, int, str, type(None))):
+        return obj
+    elif isinstance(obj, float):
+        if not math.isfinite(obj):
+            if math.isnan(obj):
+                return "NaN"
+            return "Infinity" if obj > 0 else "-Infinity"
+        return obj
+    if depth > _MAX_SERIALIZE_DEPTH:
+        return "<max depth>"
+    elif isinstance(obj, (list, tuple)):
+        return [_serialize(x, depth + 1, node_refs) for x in obj]
+    elif getattr(obj, '__class__', None) and getattr(obj.__class__, '__name__', '') == 'deque':
+        return [_serialize(x, depth + 1, node_refs) for x in obj]
+    elif isinstance(obj, dict):
+        return {str(k): _serialize(v, depth + 1, node_refs) for k, v in obj.items()}
+    elif isinstance(obj, set):
+        # Use try/except for sorting to handle heterogeneous sets
+        try:
+            sorted_vals = sorted([_serialize(x, depth + 1, node_refs) for x in obj])
+        except TypeError:
+            sorted_vals = [_serialize(x, depth + 1, node_refs) for x in obj]
+        return {"__type__": "set", "values": sorted_vals}
+    elif (hasattr(obj, 'val') or hasattr(obj, 'value')) and (hasattr(obj, 'left') or hasattr(obj, 'right')):
+        obj_ref = id(obj)
+        if obj_ref in node_refs:
+            return {"__ref__": node_refs[obj_ref]}
+        node_id = f"tree-{obj_ref}"
+        node_refs[obj_ref] = node_id
+        result = {
+            "__type__": "TreeNode",
+            "__id__": node_id,
+            "val": _serialize(getattr(obj, 'val', getattr(obj, 'value', None)), depth + 1, node_refs),
+        }
+        if hasattr(obj, 'left'):
+            result["left"] = _serialize(obj.left, depth + 1, node_refs)
+        if hasattr(obj, 'right'):
+            result["right"] = _serialize(obj.right, depth + 1, node_refs)
+        return result
+    elif (hasattr(obj, 'val') or hasattr(obj, 'value')) and hasattr(obj, 'next'):
+        obj_ref = id(obj)
+        if obj_ref in node_refs:
+            return {"__ref__": node_refs[obj_ref]}
+        node_id = f"list-{obj_ref}"
+        node_refs[obj_ref] = node_id
+        result = {
+            "__type__": "ListNode",
+            "__id__": node_id,
+            "val": _serialize(getattr(obj, 'val', getattr(obj, 'value', None)), depth + 1, node_refs),
+        }
+        result["next"] = _serialize(obj.next, depth + 1, node_refs)
+        return result
+    elif callable(obj):
+        # Skip functions entirely - return sentinel
+        return _SKIP_SENTINEL
+    else:
+        repr_str = repr(obj)
+        # Filter out function-like representations (e.g., <function foo at 0x...>)
+        if repr_str.startswith('<') and repr_str.endswith('>'):
+            return _SKIP_SENTINEL
+        return repr_str
+`;
+var TEMPLATE_PYTHON_EXECUTE_SERIALIZE_FUNCTION = `
+_MAX_SERIALIZE_DEPTH = 48
+
+def _serialize(obj, depth=0):
+    if isinstance(obj, (bool, int, str, type(None))):
+        return obj
+    elif isinstance(obj, float):
+        if not math.isfinite(obj):
+            if math.isnan(obj):
+                return "NaN"
+            return "Infinity" if obj > 0 else "-Infinity"
+        return obj
+    if depth > _MAX_SERIALIZE_DEPTH:
+        return "<max depth>"
+    elif isinstance(obj, (list, tuple)):
+        return [_serialize(x, depth + 1) for x in obj]
+    elif getattr(obj, '__class__', None) and getattr(obj.__class__, '__name__', '') == 'deque':
+        return [_serialize(x, depth + 1) for x in obj]
+    elif isinstance(obj, dict):
+        return {str(k): _serialize(v, depth + 1) for k, v in obj.items()}
+    elif isinstance(obj, set):
+        try:
+            return {"__type__": "set", "values": sorted([_serialize(x, depth + 1) for x in obj])}
+        except TypeError:
+            return {"__type__": "set", "values": [_serialize(x, depth + 1) for x in obj]}
+    elif (hasattr(obj, 'val') or hasattr(obj, 'value')) and (hasattr(obj, 'left') or hasattr(obj, 'right')):
+        result = {"__type__": "TreeNode", "val": _serialize(getattr(obj, 'val', getattr(obj, 'value', None)), depth + 1)}
+        if hasattr(obj, 'left'):
+            result["left"] = _serialize(obj.left, depth + 1)
+        if hasattr(obj, 'right'):
+            result["right"] = _serialize(obj.right, depth + 1)
+        return result
+    elif (hasattr(obj, 'val') or hasattr(obj, 'value')) and hasattr(obj, 'next'):
+        result = {"__type__": "ListNode", "val": _serialize(getattr(obj, 'val', getattr(obj, 'value', None)), depth + 1)}
+        result["next"] = _serialize(obj.next, depth + 1)
+        return result
+    elif callable(obj):
+        return None
+    else:
+        repr_str = repr(obj)
+        if repr_str.startswith('<') and repr_str.endswith('>'):
+            return None
+        return repr_str
+`;
+var TEMPLATE_PYTHON_PRACTICE_MATERIALIZE_SERIALIZE_FUNCTION = `
+def _serialize(obj, depth=0, state=None):
+    if state is None:
+        state = {"nodes": 0, "seen": set()}
+    if depth > 64:
+        return "__MAX_DEPTH__"
+    if isinstance(obj, (int, float, str, bool, type(None))):
+        return obj
+
+    state["nodes"] += 1
+    if state["nodes"] > 600:
+        return "__MAX_NODES__"
+
+    if isinstance(obj, (list, tuple)):
+        return [_serialize(x, depth + 1, state) for x in obj]
+    elif isinstance(obj, dict):
+        return {str(k): _serialize(v, depth + 1, state) for k, v in obj.items()}
+    elif isinstance(obj, set):
+        serialized = [_serialize(x, depth + 1, state) for x in obj]
+        try:
+            serialized = sorted(serialized)
+        except TypeError:
+            pass
+        return {"__type__": "set", "values": serialized}
+    elif (hasattr(obj, 'val') or hasattr(obj, 'value')) and (hasattr(obj, 'left') or hasattr(obj, 'right')):
+        obj_id = id(obj)
+        if obj_id in state["seen"]:
+            return "__CYCLE__"
+        state["seen"].add(obj_id)
+        result = {"__type__": "TreeNode", "val": _serialize(getattr(obj, 'val', getattr(obj, 'value', None)), depth + 1, state)}
+        if hasattr(obj, 'left'):
+            result["left"] = _serialize(obj.left, depth + 1, state)
+        if hasattr(obj, 'right'):
+            result["right"] = _serialize(obj.right, depth + 1, state)
+        state["seen"].remove(obj_id)
+        return result
+    elif (hasattr(obj, 'val') or hasattr(obj, 'value')) and hasattr(obj, 'next'):
+        obj_id = id(obj)
+        if obj_id in state["seen"]:
+            return "__CYCLE__"
+        state["seen"].add(obj_id)
+        result = {"__type__": "ListNode", "val": _serialize(getattr(obj, 'val', getattr(obj, 'value', None)), depth + 1, state)}
+        result["next"] = _serialize(obj.next, depth + 1, state)
+        state["seen"].remove(obj_id)
+        return result
+    else:
+        return repr(obj)
+`;
+var TEMPLATE_PYTHON_INTERVIEW_MATERIALIZE_SERIALIZE_FUNCTION = `
+def _serialize(obj, depth=0):
+    if depth > 10:
+        return "<max depth>"
+    if isinstance(obj, (int, float, str, bool, type(None))):
+        return obj
+    elif isinstance(obj, (list, tuple)):
+        return [_serialize(x, depth + 1) for x in obj]
+    elif isinstance(obj, dict):
+        return {str(k): _serialize(v, depth + 1) for k, v in obj.items()}
+    elif isinstance(obj, set):
+        try:
+            return {"__type__": "set", "values": sorted([_serialize(x, depth + 1) for x in obj])}
+        except TypeError:
+            return {"__type__": "set", "values": [_serialize(x, depth + 1) for x in obj]}
+    elif hasattr(obj, 'val') and (hasattr(obj, 'left') or hasattr(obj, 'right')):
+        result = {"__type__": "TreeNode", "val": _serialize(getattr(obj, 'val', None), depth + 1)}
+        if hasattr(obj, 'left'):
+            result["left"] = _serialize(obj.left, depth + 1)
+        if hasattr(obj, 'right'):
+            result["right"] = _serialize(obj.right, depth + 1)
+        return result
+    elif hasattr(obj, 'val') and hasattr(obj, 'next'):
+        result = {"__type__": "ListNode", "val": _serialize(getattr(obj, 'val', None), depth + 1)}
+        result["next"] = _serialize(obj.next, depth + 1)
+        return result
+    else:
+        return repr(obj)
+`;
+var TEMPLATE_PYTHON_SERIALIZE_FUNCTION = TEMPLATE_PYTHON_EXECUTE_SERIALIZE_FUNCTION;
+
+// packages/harness-javascript/src/typescript-runtime-declarations.ts
+var TYPESCRIPT_RUNTIME_DECLARATIONS = `
+declare class ListNode {
+  val: any;
+  next: ListNode | SerializedListNode | SerializedRef | null;
+  prev?: ListNode | SerializedListNode | SerializedRef | null;
+  constructor(val?: any, next?: ListNode | null);
+}
+
+declare class TreeNode {
+  val: any;
+  left: TreeNode | SerializedTreeNode | SerializedRef | null;
+  right: TreeNode | SerializedTreeNode | SerializedRef | null;
+  constructor(val?: any, left?: TreeNode | null, right?: TreeNode | null);
+}
+
+type SerializedRef = { __ref__: string };
+
+type SerializedListNode = {
+  __id__?: string;
+  __type__?: 'ListNode';
+  val?: any;
+  next?: SerializedListNode | SerializedRef | ListNode | null;
+  prev?: SerializedListNode | SerializedRef | ListNode | null;
+};
+
+type SerializedTreeNode = {
+  __id__?: string;
+  __type__?: 'TreeNode';
+  val?: any;
+  left?: SerializedTreeNode | SerializedRef | TreeNode | null;
+  right?: SerializedTreeNode | SerializedRef | TreeNode | null;
+};
+`;
+function withTypeScriptRuntimeDeclarations(sourceCode) {
+  return `${sourceCode}
+
+${TYPESCRIPT_RUNTIME_DECLARATIONS}
+`;
+}
+
+// packages/harness-javascript/src/javascript-executor.ts
+var typeScriptModulePromise = null;
+async function getTypeScriptModule() {
+  if (!typeScriptModulePromise) {
+    const specifier = "typescript";
+    typeScriptModulePromise = import(
+      /* webpackIgnore: true */
+      specifier
+    );
+  }
+  return typeScriptModulePromise;
+}
+function performanceNow() {
+  if (typeof performance !== "undefined" && typeof performance.now === "function") {
+    return performance.now();
+  }
+  return Date.now();
+}
+function formatConsoleArg(value) {
+  if (typeof value === "string") return value;
+  if (typeof value === "number" || typeof value === "boolean" || value === null || value === void 0) {
+    return String(value);
+  }
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return String(value);
+  }
+}
+function createConsoleProxy(output) {
+  const capture = (...args) => {
+    output.push(args.map(formatConsoleArg).join(" "));
+  };
+  return {
+    ...console,
+    log: capture,
+    info: capture,
+    warn: capture,
+    error: capture,
+    debug: capture
+  };
+}
+function isLikelyTreeNodeValue(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+  const hasValue = "val" in value || "value" in value;
+  const hasTreeLinks = "left" in value || "right" in value;
+  return hasValue && hasTreeLinks;
+}
+function isLikelyListNodeValue(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+  const hasValue = "val" in value || "value" in value;
+  const hasTreeLinks = "left" in value || "right" in value;
+  const hasListLinks = "next" in value || "prev" in value;
+  return hasValue && hasListLinks && !hasTreeLinks;
+}
+function serializeValue(value, depth = 0, seen = /* @__PURE__ */ new WeakSet(), nodeRefState = { ids: /* @__PURE__ */ new Map(), nextId: 1 }) {
+  if (depth > 48) return "<max depth>";
+  if (value === null || value === void 0) return value;
+  if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+    return value;
+  }
+  if (typeof value === "bigint") {
+    return Number.isSafeInteger(Number(value)) ? Number(value) : String(value);
+  }
+  if (typeof value === "function") {
+    return "<function>";
+  }
+  if (Array.isArray(value)) {
+    return value.map((item) => serializeValue(item, depth + 1, seen));
+  }
+  if (value instanceof Set) {
+    return {
+      __type__: "set",
+      values: [...value].map((item) => serializeValue(item, depth + 1, seen, nodeRefState))
+    };
+  }
+  if (value instanceof Map) {
+    return {
+      __type__: "map",
+      entries: [...value.entries()].map(([k, v]) => [
+        serializeValue(k, depth + 1, seen, nodeRefState),
+        serializeValue(v, depth + 1, seen, nodeRefState)
+      ])
+    };
+  }
+  if (typeof value === "object") {
+    if (isLikelyTreeNodeValue(value) || isLikelyListNodeValue(value)) {
+      const objectValue = value;
+      const nodeValue = value;
+      const existingId = nodeRefState.ids.get(objectValue);
+      if (existingId) {
+        return { __ref__: existingId };
+      }
+      const isTree = isLikelyTreeNodeValue(value);
+      const nodePrefix = isTree ? "tree" : "list";
+      const nodeId = `${nodePrefix}-${nodeRefState.nextId++}`;
+      nodeRefState.ids.set(objectValue, nodeId);
+      if (isTree) {
+        return {
+          __type__: "TreeNode",
+          __id__: nodeId,
+          val: serializeValue(nodeValue.val ?? nodeValue.value ?? null, depth + 1, seen, nodeRefState),
+          left: serializeValue(nodeValue.left ?? null, depth + 1, seen, nodeRefState),
+          right: serializeValue(nodeValue.right ?? null, depth + 1, seen, nodeRefState)
+        };
+      }
+      return {
+        __type__: "ListNode",
+        __id__: nodeId,
+        val: serializeValue(nodeValue.val ?? nodeValue.value ?? null, depth + 1, seen, nodeRefState),
+        next: serializeValue(nodeValue.next ?? null, depth + 1, seen, nodeRefState),
+        ..."prev" in nodeValue ? { prev: serializeValue(nodeValue.prev ?? null, depth + 1, seen, nodeRefState) } : {}
+      };
+    }
+    if (seen.has(value)) return "<cycle>";
+    seen.add(value);
+    const out = {};
+    for (const [k, v] of Object.entries(value)) {
+      out[k] = serializeValue(v, depth + 1, seen, nodeRefState);
+    }
+    seen.delete(value);
+    return out;
+  }
+  return String(value);
+}
+function extractUserErrorLine(error) {
+  if (typeof error === "object" && error && "__tracecodeLine" in error) {
+    const line2 = Number(error.__tracecodeLine);
+    if (Number.isFinite(line2)) return line2;
+  }
+  const stack = typeof error === "object" && error && "stack" in error ? String(error.stack ?? "") : "";
+  if (!stack) return void 0;
+  const match = stack.match(/<anonymous>:(\d+):\d+/);
+  if (!match) return void 0;
+  const line = Number.parseInt(match[1], 10);
+  return Number.isFinite(line) ? line : void 0;
+}
+function isPlainObjectRecord(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+  return Object.prototype.toString.call(value) === "[object Object]";
+}
+function collectReferenceTargets(value, byId, seen) {
+  if (value === null || value === void 0) return;
+  if (typeof value !== "object") return;
+  if (seen.has(value)) return;
+  seen.add(value);
+  if (Array.isArray(value)) {
+    for (const item of value) {
+      collectReferenceTargets(item, byId, seen);
+    }
+    return;
+  }
+  if (!isPlainObjectRecord(value)) return;
+  if (typeof value.__id__ === "string" && value.__id__.length > 0 && !byId.has(value.__id__)) {
+    byId.set(value.__id__, value);
+  }
+  for (const nested of Object.values(value)) {
+    collectReferenceTargets(nested, byId, seen);
+  }
+}
+function resolveReferenceGraph(value, byId, resolved) {
+  if (value === null || value === void 0) return value;
+  if (typeof value !== "object") return value;
+  if (resolved.has(value)) {
+    return resolved.get(value);
+  }
+  if (Array.isArray(value)) {
+    const out2 = [];
+    resolved.set(value, out2);
+    for (const item of value) {
+      out2.push(resolveReferenceGraph(item, byId, resolved));
+    }
+    return out2;
+  }
+  if (!isPlainObjectRecord(value)) {
+    return value;
+  }
+  const keys = Object.keys(value);
+  if (keys.length === 1 && typeof value.__ref__ === "string") {
+    const target = byId.get(value.__ref__);
+    if (!target) return null;
+    return resolveReferenceGraph(target, byId, resolved);
+  }
+  const out = {};
+  resolved.set(value, out);
+  for (const [key, nested] of Object.entries(value)) {
+    out[key] = resolveReferenceGraph(nested, byId, resolved);
+  }
+  return out;
+}
+function normalizeInputs(inputs) {
+  if (!inputs || typeof inputs !== "object" || Array.isArray(inputs)) return {};
+  const byId = /* @__PURE__ */ new Map();
+  collectReferenceTargets(inputs, byId, /* @__PURE__ */ new WeakSet());
+  if (byId.size === 0) {
+    return inputs;
+  }
+  const hydrated = resolveReferenceGraph(inputs, byId, /* @__PURE__ */ new WeakMap());
+  if (!hydrated || typeof hydrated !== "object" || Array.isArray(hydrated)) {
+    return inputs;
+  }
+  return hydrated;
+}
+function collectSimpleParameterNames(ts, functionLikeNode) {
+  const names = [];
+  for (const parameter of functionLikeNode.parameters ?? []) {
+    if (!ts.isIdentifier(parameter.name)) {
+      return null;
+    }
+    if (parameter.name.text === "this") {
+      continue;
+    }
+    names.push(parameter.name.text);
+  }
+  return names;
+}
+function getPropertyNameText(ts, name) {
+  if (!name) return null;
+  if (ts.isIdentifier(name) || ts.isStringLiteral(name) || ts.isNumericLiteral(name)) {
+    return name.text;
+  }
+  return null;
+}
+function findFunctionLikeNode(ts, sourceFile, functionName, executionStyle) {
+  let found = null;
+  const visit = (node) => {
+    if (found) return;
+    if (executionStyle === "solution-method" && ts.isClassDeclaration(node) && node.name?.text === "Solution") {
+      for (const member of node.members) {
+        if (found) break;
+        if (ts.isMethodDeclaration(member) && getPropertyNameText(ts, member.name) === functionName) {
+          found = member;
+          break;
+        }
+        if (ts.isPropertyDeclaration(member) && getPropertyNameText(ts, member.name) === functionName && member.initializer && (ts.isArrowFunction(member.initializer) || ts.isFunctionExpression(member.initializer))) {
+          found = member.initializer;
+          break;
+        }
+      }
+      return;
+    }
+    if (executionStyle === "function") {
+      if (ts.isFunctionDeclaration(node) && node.name?.text === functionName) {
+        found = node;
+        return;
+      }
+      if (ts.isVariableDeclaration(node) && ts.isIdentifier(node.name) && node.name.text === functionName && node.initializer && (ts.isArrowFunction(node.initializer) || ts.isFunctionExpression(node.initializer))) {
+        found = node.initializer;
+        return;
+      }
+    }
+    ts.forEachChild(node, visit);
+  };
+  visit(sourceFile);
+  return found;
+}
+async function resolveOrderedInputKeys(code, functionName, inputs, executionStyle) {
+  const fallbackKeys = Object.keys(inputs);
+  if (!functionName || executionStyle === "ops-class" || fallbackKeys.length <= 1) {
+    return fallbackKeys;
+  }
+  try {
+    const ts = await getTypeScriptModule();
+    const sourceFile = ts.createSourceFile("runtime-input.js", code, ts.ScriptTarget.ES2020, true, ts.ScriptKind.JS);
+    const target = findFunctionLikeNode(ts, sourceFile, functionName, executionStyle);
+    if (!target) {
+      return fallbackKeys;
+    }
+    const parameterNames = collectSimpleParameterNames(ts, target);
+    if (!parameterNames || parameterNames.length === 0) {
+      return fallbackKeys;
+    }
+    const matchedKeys = parameterNames.filter((name) => Object.prototype.hasOwnProperty.call(inputs, name));
+    if (matchedKeys.length === 0) {
+      return fallbackKeys;
+    }
+    const extras = fallbackKeys.filter((key) => !matchedKeys.includes(key));
+    return [...matchedKeys, ...extras];
+  } catch {
+    return fallbackKeys;
+  }
+}
+function buildRunner(code, executionStyle, argNames) {
+  if (executionStyle === "function") {
+    return new Function(
+      "console",
+      "__functionName",
+      ...argNames,
+      `"use strict";
+${code}
+let __target;
+try {
+  __target = eval(__functionName);
+} catch (_err) {
+  __target = undefined;
+}
+if (typeof __target !== 'function') {
+  throw new Error('Function "' + __functionName + '" not found');
+}
+return __target(${argNames.join(", ")});`
+    );
+  }
+  if (executionStyle === "solution-method") {
+    return new Function(
+      "console",
+      "__functionName",
+      ...argNames,
+      `"use strict";
+${code}
+if (typeof Solution !== 'function') {
+  throw new Error('Class "Solution" not found');
+}
+const __solver = new Solution();
+const __method = __solver[__functionName];
+if (typeof __method !== 'function') {
+  throw new Error('Method "Solution.' + __functionName + '" not found');
+}
+return __method.call(__solver, ${argNames.join(", ")});`
+    );
+  }
+  if (executionStyle === "ops-class") {
+    return new Function(
+      "console",
+      "__className",
+      "__operations",
+      "__arguments",
+      `"use strict";
+${code}
+if (!Array.isArray(__operations) || !Array.isArray(__arguments)) {
+  throw new Error('ops-class execution requires inputs.operations and inputs.arguments (or ops/args)');
+}
+if (__operations.length !== __arguments.length) {
+  throw new Error('operations and arguments must have the same length');
+}
+let __targetClass;
+try {
+  __targetClass = eval(__className);
+} catch (_err) {
+  __targetClass = undefined;
+}
+if (typeof __targetClass !== 'function') {
+  throw new Error('Class "' + __className + '" not found');
+}
+let __instance = null;
+const __out = [];
+for (let __i = 0; __i < __operations.length; __i++) {
+  const __op = __operations[__i];
+  let __callArgs = __arguments[__i];
+  if (__callArgs === null || __callArgs === undefined) {
+    __callArgs = [];
+  }
+  if (!Array.isArray(__callArgs)) {
+    __callArgs = [__callArgs];
+  }
+  if (__i === 0) {
+    __instance = new __targetClass(...__callArgs);
+    __out.push(null);
+    continue;
+  }
+  if (!__instance || typeof __instance[__op] !== 'function') {
+    throw new Error('Required method "' + __op + '" is not implemented on ' + (__className || 'target class'));
+  }
+  __out.push(__instance[__op](...__callArgs));
+}
+return __out;`
+    );
+  }
+  throw new Error(`Execution style "${executionStyle}" is not supported for JavaScript runtime yet.`);
+}
+function getOpsClassInputs(inputs) {
+  const operations = Array.isArray(inputs.operations) ? inputs.operations : Array.isArray(inputs.ops) ? inputs.ops : null;
+  const argumentsList = Array.isArray(inputs.arguments) ? inputs.arguments : Array.isArray(inputs.args) ? inputs.args : null;
+  return { operations, argumentsList };
+}
+async function transpileTypeScript(code) {
+  const ts = await getTypeScriptModule();
+  const transpileInput = withTypeScriptRuntimeDeclarations(code);
+  const transpiled = ts.transpileModule(transpileInput, {
+    compilerOptions: {
+      target: ts.ScriptTarget.ES2020,
+      module: ts.ModuleKind.None,
+      strict: false,
+      esModuleInterop: true
+    },
+    reportDiagnostics: true,
+    fileName: "solution.ts"
+  });
+  const diagnostics = Array.isArray(transpiled.diagnostics) ? transpiled.diagnostics : [];
+  const errors = diagnostics.filter((diag) => diag.category === ts.DiagnosticCategory.Error);
+  if (errors.length > 0) {
+    const first = errors[0];
+    const messageText = ts.flattenDiagnosticMessageText(first.messageText, "\n");
+    let lineNumber;
+    if (first.file && typeof first.start === "number") {
+      const position = first.file.getLineAndCharacterOfPosition(first.start);
+      lineNumber = position.line + 1;
+    }
+    const error = new Error(
+      lineNumber ? `TypeScript transpilation failed (line ${lineNumber}): ${messageText}` : `TypeScript transpilation failed: ${messageText}`
+    );
+    if (lineNumber) {
+      error.__tracecodeLine = lineNumber;
+    }
+    throw error;
+  }
+  return transpiled.outputText;
+}
+async function executeJavaScriptCode(code, functionName, inputs, executionStyle = "function") {
+  const consoleOutput = [];
+  const consoleProxy = createConsoleProxy(consoleOutput);
+  const normalizedInputs = normalizeInputs(inputs);
+  try {
+    let output;
+    if (executionStyle === "ops-class") {
+      const { operations, argumentsList } = getOpsClassInputs(normalizedInputs);
+      const runner = buildRunner(code, executionStyle, []);
+      output = await Promise.resolve(runner(consoleProxy, functionName, operations, argumentsList));
+    } else {
+      const inputKeys = await resolveOrderedInputKeys(code, functionName, normalizedInputs, executionStyle);
+      const argNames = inputKeys.map((_, index) => `__arg${index}`);
+      const argValues = inputKeys.map((key) => normalizedInputs[key]);
+      const runner = buildRunner(code, executionStyle, argNames);
+      output = await Promise.resolve(runner(consoleProxy, functionName, ...argValues));
+    }
+    return {
+      success: true,
+      output: serializeValue(output),
+      consoleOutput
+    };
+  } catch (error) {
+    return {
+      success: false,
+      output: null,
+      error: error instanceof Error ? error.message : String(error),
+      errorLine: extractUserErrorLine(error),
+      consoleOutput
+    };
+  }
+}
+async function executeJavaScriptWithTracing(code, functionName, inputs, executionStyle = "function") {
+  const startedAt = performanceNow();
+  const codeResult = await executeJavaScriptCode(code, functionName ?? "", inputs, executionStyle);
+  const executionTimeMs = performanceNow() - startedAt;
+  if (!codeResult.success) {
+    return {
+      success: false,
+      error: codeResult.error,
+      errorLine: codeResult.errorLine,
+      trace: [],
+      executionTimeMs,
+      consoleOutput: codeResult.consoleOutput ?? [],
+      lineEventCount: 0,
+      traceStepCount: 0
+    };
+  }
+  return {
+    success: true,
+    output: codeResult.output,
+    trace: [],
+    executionTimeMs,
+    consoleOutput: codeResult.consoleOutput ?? [],
+    lineEventCount: 0,
+    traceStepCount: 0
+  };
+}
+async function executeTypeScriptCode(code, functionName, inputs, executionStyle = "function") {
+  const transpiledCode = await transpileTypeScript(code);
+  return executeJavaScriptCode(transpiledCode, functionName, inputs, executionStyle);
+}
+export {
+  DEFAULT_BROWSER_HARNESS_ASSET_RELATIVE_PATHS,
+  LANGUAGE_RUNTIME_PROFILES,
+  PYTHON_CLASS_DEFINITIONS,
+  PYTHON_CONVERSION_HELPERS,
+  PYTHON_EXECUTE_SERIALIZE_FUNCTION,
+  PYTHON_INTERVIEW_MATERIALIZE_SERIALIZE_FUNCTION,
+  PYTHON_PRACTICE_MATERIALIZE_SERIALIZE_FUNCTION,
+  PYTHON_SERIALIZE_FUNCTION,
+  PYTHON_TRACE_SERIALIZE_FUNCTION,
+  RUNTIME_TRACE_CONTRACT_SCHEMA_VERSION,
+  SUPPORTED_LANGUAGES,
+  TEMPLATE_PYTHON_CLASS_DEFINITIONS,
+  TEMPLATE_PYTHON_CONVERSION_HELPERS,
+  TEMPLATE_PYTHON_EXECUTE_SERIALIZE_FUNCTION,
+  TEMPLATE_PYTHON_INTERVIEW_MATERIALIZE_SERIALIZE_FUNCTION,
+  TEMPLATE_PYTHON_PRACTICE_MATERIALIZE_SERIALIZE_FUNCTION,
+  TEMPLATE_PYTHON_SERIALIZE_FUNCTION,
+  TEMPLATE_PYTHON_TRACE_SERIALIZE_FUNCTION,
+  TYPESCRIPT_RUNTIME_DECLARATIONS,
+  adaptJavaScriptTraceExecutionResult,
+  adaptPythonTraceExecutionResult,
+  adaptTraceExecutionResult,
+  assertRuntimeRequestSupported,
+  createBrowserHarness,
+  executeJavaScriptCode,
+  executeJavaScriptWithTracing,
+  executeTypeScriptCode,
+  generateConversionCode,
+  generateInputSetup,
+  generateSolutionScript,
+  getLanguageRuntimeProfile,
+  getSupportedLanguageProfiles,
+  identifyConversions,
+  isLanguageSupported,
+  normalizeRuntimeTraceContract,
+  resolveBrowserHarnessAssets,
+  stableStringifyRuntimeTraceContract,
+  templateToPythonLiteral,
+  toPythonLiteral,
+  withTypeScriptRuntimeDeclarations
+};
+//# sourceMappingURL=index.js.map