feat(bin): run solve fns in workers

this protects imports from one solve module leaking into another

it also accounts for solutions that don't gracefully close resources (e.g. `z3-solver` currently used for 2025 Day 10 Part 2)

Author: mfulton26

2025/day/10/part/2/solve.ts

@@ -1,12 +1,28 @@
+import { init } from "z3-solver";
+import { parseManual } from "../../manuals.ts";
+
 export default async function solve(input: string) {
-  const { href: workerUrl } = new URL("./worker.ts", import.meta.url);
-  const worker = new Worker(workerUrl, { type: "module" });
-  try {
-    const { promise, resolve } = Promise.withResolvers<number>();
-    worker.onmessage = ({ data }) => resolve(data);
-    worker.postMessage(input);
-    return await promise;
-  } finally {
-    worker.terminate();
+  const manual = parseManual(input);
+  const { Context } = await init();
+  const { Int, Optimize } = Context("main");
+  let sum = 0;
+  for (const { buttons, requirements } of manual) {
+    const variables = buttons.map((_, i) => Int.const(`b${i}`));
+    const optimize = new Optimize();
+    optimize.add(
+      ...requirements.map((requirement, lightIndex) =>
+        buttons.keys()
+          .filter((buttonIndex) => buttons[buttonIndex].includes(lightIndex))
+          .map((buttonIndex) => variables[buttonIndex])
+          .reduce((a, b) => a.add(b), Int.val(0))
+          .eq(Int.val(requirement))
+      ),
+      ...variables.map((variable) => variable.ge(0)),
+    );
+    const sumExpression = variables.reduce((a, x) => a.add(x), Int.val(0));
+    optimize.minimize(sumExpression);
+    if (await optimize.check() !== "sat") throw new Error("No solution found");
+    sum += +optimize.model().eval(sumExpression);
   }
+  return sum;
 }

2025/day/10/part/2/worker.ts

@@ -8,7 +8,8 @@ import { bold, gray, red } from "@std/fmt/colors";
 import prettyMs from "pretty-ms";
 
 import { alphanumericalCompareFn } from "@lib/alphanumeric.ts";
-import { formatAnswer, getSolveFn } from "@lib/harness.ts";
+import { formatAnswer } from "@lib/harness.ts";
+import type { InputData, OutputData } from "./worker.ts";
 
 const defaultBaseUrl = "https://adventofcode.com";
 
@@ -127,15 +128,19 @@ async function solve(
   for (const moduleName of new Set(moduleNames)) {
     const { year, day } = groupsByModuleName.get(moduleName)!;
     const input = await getInput(year, day, session, cachePath);
-    const solve = await getSolveFn(`.${moduleName}`);
-    if (solve === undefined) {
-      console.log(gray(`no default exported function found in ${moduleName}`));
-      continue;
-    }
-    console.log(gray(`running solve from ${moduleName}`));
+    const { href: workerUrl } = new URL("./worker.ts", import.meta.url);
+    const worker = new Worker(workerUrl, { type: "module" });
     try {
+      const { promise, resolve, reject } = Promise.withResolvers();
+      worker.onmessage = ({ data: { key, value } }: MessageEvent<OutputData>) =>
+        ({ answer: resolve, error: reject })[key](value);
+      worker.onerror = ({ error }) => reject(error);
+      worker.onmessageerror = (cause) =>
+        reject(new Error("failed to receive message from worker", { cause }));
+      console.log(gray(`running solve from ${moduleName}`));
+      worker.postMessage({ input, moduleName } satisfies InputData);
       const start = performance.now();
-      const answer = await solve(input);
+      const answer = await promise;
       const end = performance.now();
       const duration = end - start;
       console.log(
@@ -145,6 +150,8 @@ async function solve(
       if (answer !== undefined) solved++;
     } catch (e) {
       console.error(e);
+    } finally {
+      worker.terminate();
     }
   }
 

bin/aoc.ts

@@ -0,0 +1,28 @@
+/// <reference lib="deno.worker" />
+
+import { getSolveFn } from "@lib/harness.ts";
+
+export interface InputData {
+  input: string;
+  moduleName: string;
+}
+
+export interface OutputData {
+  key: "answer" | "error";
+  value: unknown;
+}
+
+self.onmessage = async (
+  { data: { input, moduleName } }: MessageEvent<InputData>,
+) => {
+  try {
+    const solve = await getSolveFn(`.${moduleName}`);
+    if (solve === undefined) {
+      throw Error(`no default exported function found in ${moduleName}`);
+    }
+    const answer = await solve(input);
+    self.postMessage({ key: "answer", value: answer } satisfies OutputData);
+  } catch (error) {
+    self.postMessage({ key: "error", value: error } satisfies OutputData);
+  }
+};