Square root multiples This code-challenge is based on OEIS sequence A261865.

\$A261865(n)\$ is the least integer \$k\$ such that some multiple of \$\sqrt{k}\$ is in the interval \$(n,n+1)\$.

The goal of this challenge is to write a program that can find a value of \$n\$ that makes \$A261865(n)\$ as large as you can. A brute-force program can probably do okay, but there are other methods that you might use to do even better.
Example
For example, \$A261865(3) = 3\$ because

there is no multiple of \$\sqrt{1}\$ in \$(3,4)\$ (since \$3 \sqrt{1} \leq 3\$ and \$4 \sqrt{1} \geq 4\$);
there is no multiple of \$\sqrt{2}\$ in \$(3,4)\$ (since \$2 \sqrt{2} \leq 3\$ and \$3 \sqrt{2} \geq 4\$);
and there is a multiple of \$\sqrt{3}\$ in \$(3,4)\$, namely \$2\sqrt{3} \approx 3.464\$.

Analysis
Large values in this sequence are rare!

70.7% of the values are \$2\$s,
16.9% of the values are \$3\$s,
5.5% of the values are \$5\$s,
2.8% of the values are \$6\$s,
1.5% of the values are \$7\$s,
0.8% of the values are \$10\$s, and
1.7% of the values are \$\geq 11\$.

Challenge
The goal of this code-challenge is to write a program that finds a value of \$n\$ that makes \$A261865(n)\$ as large as possible. Your program should run for no more than one minute and should output a number \$n\$. Your score is given by \$A261865(n)\$. In the case of a close call, I will run all entries on my 2017 MacBook Pro with 8GB of RAM to determine the winner.
For example, you program might output \$A261865(257240414)=227\$ for a score of 227. If two entries get the same score, whichever does it faster on my machine is the winner.
(Your program should not rely on information about pre-computed values, unless you can justify that information with a heuristic or a proof.)
JavaScript (Node.js), score \$335\$
Pretty straight-forward algorithm. I made it multithreaded to be a bit faster.
// Run with: node ./square-root-multiples.js

const findMaxK = (fromN, toN) =&gt; {
  let maxK = 0;
  let maxN = 0;
  for (let n = fromN; n &lt; toN; n++) {
    for (let k = 2, s = n * n; k &lt; s; k++) {
      const r = Math.sqrt(k);
      const x = r * Math.ceil(n / r);
      if (x &gt; n &amp;&amp; x &lt; n + 1) {
        if (k &gt; maxK) {
          maxK = k;
          maxN = n;
        }
        break;
      }
    }
  }
  return { n: maxN, k: maxK };
};

const BATCH_SIZE = 10000000;

const cluster = require(&quot;cluster&quot;);
if (cluster.isMaster) {
  const start = Date.now();
  let nextBatch = 0;
  let maxK = 0;

  const numCpus = require(&quot;os&quot;).cpus().length;
  for (let i = 0; i &lt; numCpus; i++) {
    const worker = cluster.fork();
    worker.on(&quot;message&quot;, (msg) =&gt; {
      if (msg.k &gt; maxK) {
        maxK = msg.k;
        console.log(
          `found A261865(${msg.n}) = ${msg.k} in ${
            (Date.now() - start) / 1000
          }s`
        );
      }
      worker.send({ n: nextBatch, maxK });
      nextBatch += BATCH_SIZE;
    });
    worker.send({ n: nextBatch });
    nextBatch += BATCH_SIZE;
  }
} else {
  process.on(&quot;message&quot;, (msg) =&gt; {
    process.send(findMaxK(msg.n, msg.n + BATCH_SIZE));
  });
}

Output on my 2019 MacBook Pro:
found A261865(12779527) = 134 in 0.299s
found A261865(2345213) = 187 in 0.308s
found A261865(63856063) = 193 in 0.33s
found A261865(222125822) = 210 in 0.681s
found A261865(237941698) = 217 in 0.687s
found A261865(257240414) = 227 in 0.804s
found A261865(1217775885) = 230 in 2.704s
found A261865(1205703469) = 267 in 2.704s
found A261865(1558293414) = 299 in 3.306s
found A261865(4641799364) = 303 in 13.002s
found A261865(6600656102) = 323 in 20.045s
found A261865(11145613453) = 335 in 36.774s
found A261865(20641456345) = 354 in 73.047s

The highest K my machine found within 60s was A261865(11145613453) = 335.