ok

apps/frontend/src/app/routes/mock.tsx

@@ -26,17 +26,17 @@ type GenerationKindStart =
   | "column-seq"
   | "column-seq-reverse"
   | "column-group-shuffle"
-  | "random-area-reverse"
-  | "block-swap";
+  | "random-rectangle-area"
+  | "random-eclipse-area";
 
 const generationKindStarts: GenerationKindStart[] = [
   "all-random",
   "gen-random",
   "column-seq",
   "column-seq-reverse",
   "column-group-shuffle",
-  "random-area-reverse",
-  "block-swap",
+  "random-rectangle-area",
+  "random-eclipse-area",
 ] as const;
 
 type GenerationKindGoal =

apps/solver/src/features/algorithm/index.ts

@@ -20,6 +20,7 @@ export class AlgorithmFeature extends FeatureBase {
   #tx: ChannelTx<UIMessageEventBase>;
   #subscriberCount$: ReadonlyStore<number>;
   readonly #solve: SolveFunc;
+  readonly #solveBeam: SolveFunc = getSolveFunc("vbeam");
 
   constructor(
     log: LogLayer,
@@ -100,19 +101,19 @@ export class AlgorithmFeature extends FeatureBase {
 
       const scope = span(this.log, "Solve finished");
 
-      const [answer, finalBoard] = await this.#solve(
+      const solvePromise = this.#solve(
         solvingState.problem,
         (workers) => {
           this.sendEvent({
             eventName: "solve.start",
             solveId: solvingState.id,
-            workers,
+            workers: workers * 2,
             startedAt: solvingState.startedAt,
             board: solvingState.problem.board,
             general: solvingState.problem.general,
           } satisfies SolveStartEvent);
 
-          solvingState.workers = workers;
+          solvingState.workers = workers * 2;
         },
         async (workerId, answer) => {
           this.sendEvent({
@@ -138,8 +139,39 @@ export class AlgorithmFeature extends FeatureBase {
         },
       );
 
+      const solveBeamPromise = this.#solveBeam(
+        solvingState.problem,
+        (workers) => {},
+        async (workerId, answer) => {
+          this.sendEvent({
+            eventName: "solve.progress",
+            solveId: solvingState.id,
+            workerId: workerId + 8,
+            turns: answer.n,
+          } satisfies SolveProgressEvent);
+
+          if (solvingState.currentShortestAnswer === null || answer.n < solvingState.currentShortestAnswer.n) {
+            solvingState.currentShortestAnswer = answer;
+
+            const [, revision] = await this.submitAnswer(solvingState.id, solvingState.problem, answer);
+
+            this.log
+              .withMetadata({
+                id: solvingState.id,
+                turns: answer.ops.length,
+                revision,
+              })
+              .info("Answer updated");
+          }
+        },
+      );
+
       scope.end();
 
+      const [answer, finalBoard] = (await Promise.all([solvePromise, solveBeamPromise])).toSorted(
+        (a: [Answer, string[]], b: [Answer, string[]]) => a[0].n - b[0].n,
+      )[0];
+
       const [correct, revision] = await this.submitAnswer(solvingState.id, solvingState.problem, answer, finalBoard);
 
       this.sendEvent({

packages/algorithm/src/index.ts

@@ -1,16 +1,15 @@
 import type { Answer, Problem } from "@data-maki/schemas";
 import { solve as solveV1 } from "./workers/v1.master";
 import { solve as solveV2 } from "./workers/v2.master";
-import { solve as solveV3 } from "./workers/v3.master";
-
+import { solve as solveVBeam } from "./workers/vbeam.master";
 export { easyKatanuki } from "./katanuki";
 
-export const VERSIONS = ["v1", "v2", "v3"] as const;
+export const VERSIONS = ["vbeam", "v1", "v2"] as const;
 
 const solveFuncs: { [key in (typeof VERSIONS)[number]]: SolveFunc } = {
+  vbeam: solveVBeam,
   v1: solveV1,
   v2: solveV2,
-  v3: solveV3,
 };
 
 export const isSolveFuncVersion = (version: string): version is (typeof VERSIONS)[number] =>