@logic-pad/core 0.6.1 → 0.9.0

package/dist/data/rules/cellCountPerZoneRule.js

@@ -58,7 +58,8 @@ class CellCountPerZoneRule extends Rule {
             };
             const stack = [seed];
             while (stack.length > 0) {
-                const { x, y } = stack.pop();
+                let { x, y } = stack.pop();
+                ({ x, y } = grid.toArrayCoordinates(x, y));
                 if (visited[y][x])
                     continue;
                 visited[y][x] = true;
@@ -71,12 +72,13 @@ class CellCountPerZoneRule extends Rule {
                     complete = false;
                 }
                 for (const offset of NEIGHBOR_OFFSETS) {
-                    const next = { x: x + offset.x, y: y + offset.y };
-                    if (!grid.zones.edges.some(e => (e.x1 === x &&
-                        e.y1 === y &&
-                        e.x2 === next.x &&
-                        e.y2 === next.y) ||
-                        (e.x1 === next.x && e.y1 === next.y && e.x2 === x && e.y2 === y))) {
+                    const next = grid.toArrayCoordinates(x + offset.x, y + offset.y);
+                    if (!grid.zones.edges.some(e => {
+                        const { x: x1, y: y1 } = grid.toArrayCoordinates(e.x1, e.y1);
+                        const { x: x2, y: y2 } = grid.toArrayCoordinates(e.x2, e.y2);
+                        return ((x1 === x && y1 === y && x2 === next.x && y2 === next.y) ||
+                            (x2 === x && y2 === y && x1 === next.x && y1 === next.y));
+                    })) {
                         const nextTile = grid.getTile(next.x, next.y);
                         if (nextTile.exists) {
                             stack.push(next);

package/dist/data/rules/regionShapeRule.js

@@ -30,9 +30,9 @@ export default class RegionShapeRule extends Rule {
             if (!seed)
                 break;
             const positions = [];
-            grid.iterateArea(seed, tile => tile.color === this.color, (_, x, y) => {
+            grid.iterateArea(seed, tile => tile.color === this.color, (_, x, y, logX, logY) => {
                 visited[y][x] = true;
-                positions.push({ x, y });
+                positions.push({ x: logX, y: logY });
             });
             const incomplete = grid.iterateArea(seed, tile => tile.color === this.color || tile.color === Color.Gray, tile => {
                 if (tile.color === Color.Gray)
@@ -46,7 +46,11 @@ export default class RegionShapeRule extends Rule {
                 existing.count++;
             }
             else {
-                regions.push({ positions, shape, count: 1 });
+                regions.push({
+                    positions: positions.map(pos => grid.toArrayCoordinates(pos.x, pos.y)),
+                    shape,
+                    count: 1,
+                });
             }
         }
         return { regions, complete };

package/dist/data/rules/rules.gen.d.ts

@@ -15,3 +15,4 @@ export { instance as SameShapeRule } from './sameShapeRule.js';
 export { instance as SymbolsPerRegionRule } from './symbolsPerRegionRule.js';
 export { instance as UndercluedRule } from './undercluedRule.js';
 export { instance as UniqueShapeRule } from './uniqueShapeRule.js';
+export { instance as WrapAroundRule } from './wrapAroundRule.js';

package/dist/data/rules/rules.gen.js

@@ -19,3 +19,4 @@ export { instance as SameShapeRule } from './sameShapeRule.js';
 export { instance as SymbolsPerRegionRule } from './symbolsPerRegionRule.js';
 export { instance as UndercluedRule } from './undercluedRule.js';
 export { instance as UniqueShapeRule } from './uniqueShapeRule.js';
+export { instance as WrapAroundRule } from './wrapAroundRule.js';

package/dist/data/rules/wrapAroundRule.d.ts

@@ -0,0 +1,34 @@
+import { AnyConfig } from '../config.js';
+import { GetTileHandler } from '../events/onGetTile.js';
+import GridData from '../grid.js';
+import { Position, RuleState, Wrapping } from '../primitives.js';
+import Rule, { SearchVariant } from './rule.js';
+export default class WrapAroundRule extends Rule implements GetTileHandler {
+    readonly horizontal: Wrapping;
+    readonly vertical: Wrapping;
+    private static readonly EXAMPLE_GRID_NONE;
+    private static readonly EXAMPLE_GRID_HORIZONTAL;
+    private static readonly EXAMPLE_GRID_VERTICAL;
+    private static readonly SEARCH_VARIANTS;
+    private static readonly CONFIGS;
+    /**
+     * **The left and right edges are connected (in reverse)**
+     *
+     * @param horizontal - The horizontal wrapping.
+     * @param vertical - The vertical wrapping.
+     */
+    constructor(horizontal: Wrapping, vertical: Wrapping);
+    onGetTile(x: number, y: number, grid: GridData): Position;
+    get id(): string;
+    get explanation(): string;
+    createExampleGrid(): GridData;
+    get configs(): readonly AnyConfig[] | null;
+    get searchVariants(): SearchVariant[];
+    validateGrid(grid: GridData): RuleState;
+    copyWith({ horizontal, vertical, }: {
+        horizontal?: Wrapping;
+        vertical?: Wrapping;
+    }): this;
+    get isSingleton(): boolean;
+}
+export declare const instance: WrapAroundRule;

package/dist/data/rules/wrapAroundRule.js

@@ -0,0 +1,271 @@
+import { ConfigType } from '../config.js';
+import { array } from '../dataHelper.js';
+import GridData from '../grid.js';
+import { Color, MajorRule, Orientation, State, Wrapping, orientationToggle, } from '../primitives.js';
+import LetterSymbol from '../symbols/letterSymbol.js';
+import MyopiaSymbol from '../symbols/myopiaSymbol.js';
+import Rule from './rule.js';
+class WrapAroundRule extends Rule {
+    /**
+     * **The left and right edges are connected (in reverse)**
+     *
+     * @param horizontal - The horizontal wrapping.
+     * @param vertical - The vertical wrapping.
+     */
+    constructor(horizontal, vertical) {
+        super();
+        Object.defineProperty(this, "horizontal", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: horizontal
+        });
+        Object.defineProperty(this, "vertical", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: vertical
+        });
+        this.horizontal = horizontal;
+        this.vertical = vertical;
+    }
+    onGetTile(x, y, grid) {
+        if (grid.width === 0 || grid.height === 0) {
+            return { x, y };
+        }
+        if (this.horizontal !== Wrapping.None) {
+            const idx = Math.abs(Math.floor(x / grid.width));
+            x = ((x % grid.width) + grid.width) % grid.width;
+            if ((this.horizontal === Wrapping.WrapReverse ||
+                this.horizontal === Wrapping.ReflectReverse) &&
+                idx % 2 === 1) {
+                y = grid.height - 1 - y;
+            }
+            if (this.horizontal === Wrapping.ReflectReverse && idx % 2 === 1) {
+                x = grid.width - 1 - x;
+            }
+        }
+        if (this.vertical !== Wrapping.None) {
+            const idx = Math.abs(Math.floor(y / grid.height));
+            y = ((y % grid.height) + grid.height) % grid.height;
+            if ((this.vertical === Wrapping.WrapReverse ||
+                this.vertical === Wrapping.ReflectReverse) &&
+                idx % 2 === 1) {
+                x = grid.width - 1 - x;
+            }
+            if (this.vertical === Wrapping.ReflectReverse && idx % 2 === 1) {
+                y = grid.height - 1 - y;
+            }
+        }
+        return { x, y };
+    }
+    get id() {
+        return MajorRule.WrapAround;
+    }
+    get explanation() {
+        if (this.horizontal === Wrapping.None && this.vertical === Wrapping.None) {
+            return `No edges are connected.`;
+        }
+        const horizontal = this.horizontal === Wrapping.None
+            ? null
+            : this.horizontal === Wrapping.Wrap ||
+                this.horizontal === Wrapping.WrapReverse
+                ? 'connected'
+                : 'reflective';
+        const vertical = this.vertical === Wrapping.None
+            ? null
+            : this.vertical === Wrapping.Wrap ||
+                this.vertical === Wrapping.WrapReverse
+                ? 'connected'
+                : 'reflective';
+        const horizontalReverse = this.horizontal === Wrapping.WrapReverse ||
+            this.horizontal === Wrapping.ReflectReverse
+            ? ' in reverse'
+            : '';
+        const verticalReverse = this.vertical === Wrapping.WrapReverse ||
+            this.vertical === Wrapping.ReflectReverse
+            ? ' in reverse'
+            : '';
+        if (this.horizontal === this.vertical) {
+            return `All four edges are ${horizontal}${horizontalReverse}.`;
+        }
+        if (this.horizontal === Wrapping.None) {
+            return `The top and bottom edges are ${vertical}${verticalReverse}.`;
+        }
+        if (this.vertical === Wrapping.None) {
+            return `The left and right edges are ${horizontal}${horizontalReverse}.`;
+        }
+        if (horizontal === vertical) {
+            if (horizontalReverse !== '') {
+                return `All four edges are ${horizontal}, with the left and right edges${horizontalReverse}.`;
+            }
+            else {
+                return `All four edges are ${horizontal}, with the top and bottom edges${verticalReverse}.`;
+            }
+        }
+        return `The left and right edges are ${horizontal}${horizontalReverse}. The top and bottom edges are ${vertical}${verticalReverse}.`;
+    }
+    createExampleGrid() {
+        const horizontal = WrapAroundRule.EXAMPLE_GRID_HORIZONTAL[this.horizontal];
+        const vertical = WrapAroundRule.EXAMPLE_GRID_VERTICAL[this.vertical];
+        if (horizontal === WrapAroundRule.EXAMPLE_GRID_NONE) {
+            return vertical;
+        }
+        else if (vertical === WrapAroundRule.EXAMPLE_GRID_NONE) {
+            return horizontal;
+        }
+        else {
+            const tiles = array(5, 5, (x, y) => {
+                const hTile = horizontal.getTile(x, y);
+                const vTile = vertical.getTile(x, y);
+                return hTile.withColor(hTile.color === Color.Dark || vTile.color === Color.Dark
+                    ? Color.Dark
+                    : Color.Light);
+            });
+            const symbols = [];
+            horizontal.symbols.forEach(list => symbols.push(...list));
+            vertical.symbols.forEach(list => symbols.push(...list));
+            return horizontal.withTiles(tiles).withSymbols(symbols);
+        }
+    }
+    get configs() {
+        return WrapAroundRule.CONFIGS;
+    }
+    get searchVariants() {
+        return WrapAroundRule.SEARCH_VARIANTS;
+    }
+    validateGrid(grid) {
+        if (grid.getTileCount(true, false, Color.Gray) > 0) {
+            return { state: State.Incomplete };
+        }
+        else {
+            return { state: State.Satisfied };
+        }
+    }
+    copyWith({ horizontal, vertical, }) {
+        return new WrapAroundRule(horizontal ?? this.horizontal, vertical ?? this.vertical);
+    }
+    get isSingleton() {
+        return true;
+    }
+}
+Object.defineProperty(WrapAroundRule, "EXAMPLE_GRID_NONE", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: Object.freeze(GridData.create(['wwwww', 'wwwww', 'wwwww', 'wwwww', 'wwwww']))
+});
+Object.defineProperty(WrapAroundRule, "EXAMPLE_GRID_HORIZONTAL", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: Object.freeze({
+        [Wrapping.None]: WrapAroundRule.EXAMPLE_GRID_NONE,
+        [Wrapping.Wrap]: GridData.create([
+            'wwwww',
+            'bwwwb',
+            'wwwww',
+            'bwwwb',
+            'wwwww',
+        ])
+            .addSymbol(new LetterSymbol(0, 1, 'A'))
+            .addSymbol(new LetterSymbol(4, 1, 'A'))
+            .addSymbol(new LetterSymbol(0, 3, 'B'))
+            .addSymbol(new LetterSymbol(4, 3, 'B')),
+        [Wrapping.WrapReverse]: GridData.create([
+            'wwwww',
+            'bwwwb',
+            'wwwww',
+            'bwwwb',
+            'wwwww',
+        ])
+            .addSymbol(new LetterSymbol(0, 1, 'A'))
+            .addSymbol(new LetterSymbol(4, 1, 'B'))
+            .addSymbol(new LetterSymbol(0, 3, 'B'))
+            .addSymbol(new LetterSymbol(4, 3, 'A')),
+        [Wrapping.ReflectReverse]: GridData.create([
+            'wwwww',
+            'bwwww',
+            'wwwww',
+            'wwwwb',
+            'wwwww',
+        ])
+            .addSymbol(new MyopiaSymbol(0, 3, false, orientationToggle(Orientation.Left)))
+            .addSymbol(new MyopiaSymbol(4, 1, false, orientationToggle(Orientation.Right))),
+    })
+});
+Object.defineProperty(WrapAroundRule, "EXAMPLE_GRID_VERTICAL", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: Object.freeze({
+        [Wrapping.None]: WrapAroundRule.EXAMPLE_GRID_NONE,
+        [Wrapping.Wrap]: GridData.create([
+            'wbwbw',
+            'wwwww',
+            'wwwww',
+            'wwwww',
+            'wbwbw',
+        ])
+            .addSymbol(new LetterSymbol(1, 0, 'C'))
+            .addSymbol(new LetterSymbol(3, 0, 'D'))
+            .addSymbol(new LetterSymbol(1, 4, 'C'))
+            .addSymbol(new LetterSymbol(3, 4, 'D')),
+        [Wrapping.WrapReverse]: GridData.create([
+            'wbwbw',
+            'wwwww',
+            'wwwww',
+            'wwwww',
+            'wbwbw',
+        ])
+            .addSymbol(new LetterSymbol(1, 0, 'C'))
+            .addSymbol(new LetterSymbol(3, 0, 'D'))
+            .addSymbol(new LetterSymbol(1, 4, 'D'))
+            .addSymbol(new LetterSymbol(3, 4, 'C')),
+        [Wrapping.ReflectReverse]: GridData.create([
+            'wbwww',
+            'wwwww',
+            'wwwww',
+            'wwwww',
+            'wwwbw',
+        ])
+            .addSymbol(new MyopiaSymbol(3, 0, false, orientationToggle(Orientation.Up)))
+            .addSymbol(new MyopiaSymbol(1, 4, false, orientationToggle(Orientation.Down))),
+    })
+});
+Object.defineProperty(WrapAroundRule, "SEARCH_VARIANTS", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: [
+        new WrapAroundRule(Wrapping.Wrap, Wrapping.None).searchVariant(),
+        new WrapAroundRule(Wrapping.None, Wrapping.Wrap).searchVariant(),
+        new WrapAroundRule(Wrapping.Wrap, Wrapping.Wrap).searchVariant(),
+        new WrapAroundRule(Wrapping.ReflectReverse, Wrapping.None).searchVariant(),
+        new WrapAroundRule(Wrapping.None, Wrapping.ReflectReverse).searchVariant(),
+        new WrapAroundRule(Wrapping.ReflectReverse, Wrapping.ReflectReverse).searchVariant(),
+    ]
+});
+Object.defineProperty(WrapAroundRule, "CONFIGS", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: Object.freeze([
+        {
+            type: ConfigType.Wrapping,
+            default: Wrapping.Wrap,
+            field: 'horizontal',
+            description: 'Horizontal wrap',
+            configurable: true,
+        },
+        {
+            type: ConfigType.Wrapping,
+            default: Wrapping.Wrap,
+            field: 'vertical',
+            description: 'Vertical wrap',
+            configurable: true,
+        },
+    ])
+});
+export default WrapAroundRule;
+export const instance = new WrapAroundRule(Wrapping.Wrap, Wrapping.Wrap);

package/dist/data/serializer/serializer_v0.js

@@ -103,6 +103,7 @@ export default class SerializerV0 extends SerializerBase {
             case ConfigType.Number:
             case ConfigType.Color:
             case ConfigType.Comparison:
+            case ConfigType.Wrapping:
             case ConfigType.Direction:
             case ConfigType.Orientation:
                 return (config.field +
@@ -190,6 +191,8 @@ export default class SerializerV0 extends SerializerBase {
                 return [config.field, value];
             case ConfigType.Comparison:
                 return [config.field, value];
+            case ConfigType.Wrapping:
+                return [config.field, value];
             case ConfigType.Direction:
                 return [config.field, value];
             case ConfigType.DirectionToggle: {

package/dist/data/solver/backtrack/backtrackSolver.d.ts

@@ -2,6 +2,7 @@ import EventIteratingSolver from '../eventIteratingSolver.js';
 export default class BacktrackSolver extends EventIteratingSolver {
     private static readonly supportedInstrs;
     readonly id = "backtrack";
+    readonly author = "ALaggyDev";
     readonly description = "Solves puzzles using backtracking with optimizations (blazingly fast). Support most rules and symbols (including underclued).";
     protected createWorker(): Worker;
     isInstructionSupported(instructionId: string): boolean;

package/dist/data/solver/backtrack/backtrackSolver.js

@@ -11,6 +11,7 @@ import { instance as galaxyInstance } from '../../symbols/galaxySymbol.js';
 import { instance as letterInstance } from '../../symbols/letterSymbol.js';
 import { instance as lotusInstance } from '../../symbols/lotusSymbol.js';
 import { instance as minesweeperInstance } from '../../symbols/minesweeperSymbol.js';
+import { instance as focusInstance } from '../../symbols/focusSymbol.js';
 import { instance as myopiaInstance } from '../../symbols/myopiaSymbol.js';
 import { instance as viewpointInstance } from '../../symbols/viewpointSymbol.js';
 import { instance as connectAllInstance } from '../z3/modules/connectAllModule.js';
@@ -24,6 +25,12 @@ class BacktrackSolver extends EventIteratingSolver {
             writable: true,
             value: 'backtrack'
         });
+        Object.defineProperty(this, "author", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 'ALaggyDev'
+        });
         Object.defineProperty(this, "description", {
             enumerable: true,
             configurable: true,
@@ -52,6 +59,7 @@ Object.defineProperty(BacktrackSolver, "supportedInstrs", {
         lotusInstance.id,
         myopiaInstance.id,
         minesweeperInstance.id,
+        focusInstance.id,
         letterInstance.id,
         undercluedInstance.id,
         connectAllInstance.id,

package/dist/data/solver/backtrack/backtrackWorker.js

@@ -14,6 +14,7 @@ import { instance as galaxyInstance, } from '../../symbols/galaxySymbol.js';
 import { instance as letterInstance, } from '../../symbols/letterSymbol.js';
 import { instance as lotusInstance, } from '../../symbols/lotusSymbol.js';
 import { instance as minesweeperInstance, } from '../../symbols/minesweeperSymbol.js';
+import { instance as focusInstance, } from '../../symbols/focusSymbol.js';
 import { instance as myopiaInstance, } from '../../symbols/myopiaSymbol.js';
 import { instance as viewpointInstance, } from '../../symbols/viewpointSymbol.js';
 import { instance as connectAllInstance } from '../z3/modules/connectAllModule.js';
@@ -33,6 +34,7 @@ import LotusBTModule from './symbols/lotus.js';
 import MinesweeperBTModule from './symbols/minesweeper.js';
 import MyopiaBTModule from './symbols/myopia.js';
 import ViewpointBTModule from './symbols/viewpoint.js';
+import FocusBTModule from './symbols/focus.js';
 function translateToBTGridData(grid) {
     const tiles = array(grid.width, grid.height, (x, y) => {
         const tile = grid.getTile(x, y);
@@ -71,6 +73,9 @@ function translateToBTGridData(grid) {
             else if (id === minesweeperInstance.id) {
                 module = new MinesweeperBTModule(symbol);
             }
+            else if (id === focusInstance.id) {
+                module = new FocusBTModule(symbol);
+            }
             else if (id === letterInstance.id) {
                 continue;
             }
@@ -289,6 +294,12 @@ onmessage = e => {
     let count = 0;
     solve(grid, solution => {
         // if (count === 0) console.timeLog('Solve time', 'First solution');
+        if (solution) {
+            if (solution.resetTiles().colorEquals(solution)) {
+                postMessage(null);
+                return false;
+            }
+        }
         postMessage(Serializer.stringifyGrid(solution));
         count += 1;
         return count < 2;

package/dist/data/solver/backtrack/symbols/focus.d.ts

@@ -0,0 +1,9 @@
+import FocusSymbol from '../../../symbols/focusSymbol.js';
+import BTModule, { BTGridData, CheckResult } from '../data.js';
+export default class FocusBTModule extends BTModule {
+    instr: FocusSymbol;
+    private cachedCheckResult?;
+    constructor(instr: FocusSymbol);
+    checkGlobal(grid: BTGridData): CheckResult | false;
+    private buildCheckAndRating;
+}

package/dist/data/solver/backtrack/symbols/focus.js

@@ -0,0 +1,59 @@
+import BTModule, { BTTile, IntArray2D, createOneTileResult, } from '../data.js';
+export default class FocusBTModule extends BTModule {
+    constructor(instr) {
+        super();
+        Object.defineProperty(this, "instr", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "cachedCheckResult", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.instr = instr;
+    }
+    checkGlobal(grid) {
+        const tile = grid.getTile(this.instr.x, this.instr.y);
+        if (tile === BTTile.Empty)
+            return createOneTileResult(grid, { x: this.instr.x, y: this.instr.y });
+        let gray = 0;
+        let same = 0;
+        for (let y = this.instr.y - 1; y <= this.instr.y + 1; y++) {
+            for (let x = this.instr.x - 1; x <= this.instr.x + 1; x++) {
+                if (y !== this.instr.y && x !== this.instr.x)
+                    continue;
+                if (!grid.isInBound(x, y) || (x === this.instr.x && y === this.instr.y))
+                    continue;
+                const checkTile = grid.getTile(x, y);
+                if (checkTile === BTTile.Empty)
+                    gray++;
+                else if (checkTile === tile)
+                    same++;
+            }
+        }
+        if (same > this.instr.number || same + gray < this.instr.number)
+            return false;
+        if (!this.cachedCheckResult)
+            this.cachedCheckResult = this.buildCheckAndRating(grid);
+        return this.cachedCheckResult;
+    }
+    buildCheckAndRating(grid) {
+        const tilesNeedCheck = IntArray2D.create(grid.width, grid.height);
+        const ratings = [];
+        for (let y = this.instr.y - 1; y <= this.instr.y + 1; y++) {
+            for (let x = this.instr.x - 1; x <= this.instr.x + 1; x++) {
+                if (y !== this.instr.y && x !== this.instr.x)
+                    continue;
+                if (!grid.isInBound(x, y) || (x === this.instr.x && y === this.instr.y))
+                    continue;
+                tilesNeedCheck.set(x, y, 1);
+                ratings.push({ pos: { x, y }, score: 1 });
+            }
+        }
+        return { tilesNeedCheck, ratings };
+    }
+}

package/dist/data/solver/eventIteratingSolver.d.ts

@@ -1,6 +1,7 @@
 import GridData from '../grid.js';
-import Solver, { CancelRef } from './solver.js';
+import Solver from './solver.js';
 export default abstract class EventIteratingSolver extends Solver {
+    readonly supportsCancellation = true;
     protected abstract createWorker(): Worker;
-    solve(grid: GridData, cancelRef: CancelRef): AsyncGenerator<GridData | null>;
+    solve(grid: GridData, abortSignal?: AbortSignal): AsyncGenerator<GridData | null>;
 }

package/dist/data/solver/eventIteratingSolver.js

@@ -2,9 +2,19 @@ import { Serializer } from '../serializer/allSerializers.js';
 import Solver from './solver.js';
 import { EventIterator } from 'event-iterator';
 export default class EventIteratingSolver extends Solver {
-    async *solve(grid, cancelRef) {
+    constructor() {
+        super(...arguments);
+        Object.defineProperty(this, "supportsCancellation", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: true
+        });
+    }
+    async *solve(grid, abortSignal) {
         const worker = this.createWorker();
-        cancelRef.cancel = () => worker.terminate();
+        const terminateHandler = () => worker.terminate();
+        abortSignal?.addEventListener('abort', terminateHandler);
         try {
             const iterator = new EventIterator(({ push, stop, fail }) => {
                 worker.postMessage(Serializer.stringifyGrid(grid.resetTiles()));
@@ -28,6 +38,7 @@ export default class EventIteratingSolver extends Solver {
         }
         finally {
             worker.terminate();
+            abortSignal?.removeEventListener('abort', terminateHandler);
         }
     }
 }

package/dist/data/solver/solver.d.ts

@@ -1,7 +1,4 @@
 import GridData from '../grid.js';
-export interface CancelRef {
-    cancel?: () => void;
-}
 /**
  * Base class that all solvers must extend.
  */
@@ -12,10 +9,18 @@ export default abstract class Solver {
      * This is also displayed to the user when selecting a solver.
      */
     abstract get id(): string;
+    /**
+     * The author(s) of the solver.
+     */
+    abstract get author(): string;
     /**
      * A short paragraph describing when the user should use this solver.
      */
     abstract get description(): string;
+    /**
+     * Whether the solver supports cancellation. If `true`, the solver must respond to the abort signal if it is provided.
+     */
+    abstract get supportsCancellation(): boolean;
     /**
      * Solve the given grid. The implementation should delegate long-running tasks to a worker thread and yield solutions
      * asynchronously.
@@ -31,10 +36,10 @@ export default abstract class Solver {
      *
      * @param grid The grid to solve. The provided grid is guaranteed to be supported by the solver. Some tiles in the
      * grid may already be filled by the user. It is up to the solver to decide whether to respect these tiles or not.
-     * @param cancelRef A reference to a function that can be called to cancel the solver. If cancellation is supported,
-     * the solver can assign a function to `cancelRef.cancel` that will stop the solver when called.
+     * @param abortSignal An optional signal that the solver should subscribe to in order to cancel the operation. If the
+     * solver does not support cancellation, it should ignore this parameter.
      */
-    abstract solve(grid: GridData, cancelRef: CancelRef): AsyncGenerator<GridData | null>;
+    abstract solve(grid: GridData, abortSignal?: AbortSignal): AsyncGenerator<GridData | null>;
     /**
      * Check if the solver supports the current browser environment. This method is called once when the user first clicks
      * the "Solve" button, and the result is cached for the duration of the editor session.

package/dist/data/solver/universal/universalSolver.d.ts

@@ -1,6 +1,7 @@
 import EventIteratingSolver from '../eventIteratingSolver.js';
 export default class UniversalSolver extends EventIteratingSolver {
     readonly id = "universal";
+    readonly author = "romain22222, Lysine";
     readonly description = "A backtracking solver that supports all rules and symbols (including underclued) but is less optimized.";
     protected createWorker(): Worker;
     isInstructionSupported(instructionId: string): boolean;

package/dist/data/solver/universal/universalSolver.js

@@ -9,6 +9,12 @@ export default class UniversalSolver extends EventIteratingSolver {
             writable: true,
             value: 'universal'
         });
+        Object.defineProperty(this, "author", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 'romain22222, Lysine'
+        });
         Object.defineProperty(this, "description", {
             enumerable: true,
             configurable: true,

package/dist/data/solver/universal/universalWorker.js

@@ -115,6 +115,11 @@ onmessage = e => {
     const grid = Serializer.parseGrid(e.data);
     let count = 0;
     solve(grid, solution => {
+        if (solution) {
+            if (solution.resetTiles().colorEquals(solution)) {
+                solution = null;
+            }
+        }
         postMessage(solution ? Serializer.stringifyGrid(solution) : null);
         count += 1;
         return count < 2;

package/dist/data/solver/z3/z3Solver.d.ts

@@ -2,7 +2,9 @@ import GridData from '../../grid.js';
 import Solver from '../solver.js';
 export default class Z3Solver extends Solver {
     readonly id = "z3";
+    readonly author = "Lysine";
     readonly description = "Good for confirming that a solution is unique, especially for larger puzzles. It is otherwise slower than most solvers in small to medium-sized puzzles.";
+    readonly supportsCancellation = false;
     isEnvironmentSupported(): Promise<boolean>;
     solve(grid: GridData): AsyncGenerator<GridData | null>;
     isInstructionSupported(instructionId: string): boolean;