@logic-pad/core 0.25.2 → 0.26.0

package/assets/logic-core.global.d.ts

@@ -8,9 +8,7 @@
 declare global {
   // Generated by dts-bundle-generator v9.5.1
 
-  import { RegionConstrainer, SymbolGrid } from 'grilops';
   import { PuzzleData as PuzzleData$1 } from 'logic-pad-solver-core';
-  import { Optimize, Solver as Solver$1, Z3LowLevel } from 'z3-solver';
   import { z } from 'zod';
 
   interface Position$1 {
@@ -454,6 +452,11 @@ declare global {
     withX(x: number): this;
     withY(y: number): this;
     withPosition(x: number, y: number): this;
+    /**
+     * For symbols that can be placed between tiles, this method implements the default validation logic,
+     * which requires all tiles touching the symbol to be either gray or of the same color.
+     */
+    protected validateSubtilePlacement(grid: GridData): boolean;
   }
   export declare class TileData {
     readonly exists: boolean;
@@ -746,6 +749,7 @@ declare global {
     get isSingleton(): boolean;
   }
   export declare const NEIGHBOR_OFFSETS: Position$1[];
+  export declare const NEIGHBOR_OFFSETS_8: Position$1[];
   export declare class GridData {
     readonly width: number;
     readonly height: number;
@@ -2387,7 +2391,7 @@ declare global {
      *
      * @param instructionId The unique identifier of the instruction.
      */
-    isInstructionSupported(instructionId: string): boolean;
+    isInstructionSupported(_grid: GridData, instruction: Instruction): boolean;
     /**
      * Check if the solver supports the given grid. This methid is frequently called when the user changes the grid, and
      * the result is used to enable or disable the "Solve" button.
@@ -2409,7 +2413,7 @@ declare global {
     readonly supportsCancellation = true;
     private static readonly nonAdditiveInstructions;
     isGridSupported(grid: GridData): boolean;
-    isInstructionSupported(instructionId: string): boolean;
+    isInstructionSupported(grid: GridData, instruction: Instruction): boolean;
     protected isEnvironmentSupported(): Promise<boolean>;
     private fillSolution;
     private fixGrid;
@@ -2436,7 +2440,7 @@ declare global {
     readonly description =
       'Solves puzzles pretty fast using backtracking with optimizations. Support most rules and symbols (including underclued).';
     protected createWorker(): Worker;
-    isInstructionSupported(instructionId: string): boolean;
+    isInstructionSupported(_grid: GridData, instruction: Instruction): boolean;
   }
   export declare enum BTTile {
     Empty = 0,
@@ -2493,6 +2497,10 @@ declare global {
     pos: Position$1,
     score?: number | undefined
   ): CheckResult;
+  export declare function checkSubtilePlacement(
+    grid: BTGridData,
+    pos: Position$1
+  ): CheckResult | false | undefined;
   export declare class BanPatternBTModule extends BTModule {
     instr: BanPatternRule;
     constructor(instr: BanPatternRule);
@@ -2554,7 +2562,7 @@ declare global {
     abstract countTiles(grid: GridData): {
       completed: number;
       possible: number;
-    };
+    } | null;
     validateSymbol(grid: GridData): State;
     withNumber(number: number): this;
   }
@@ -2577,7 +2585,7 @@ declare global {
     countTiles(grid: GridData): {
       completed: number;
       possible: number;
-    };
+    } | null;
     copyWith({
       x,
       y,
@@ -2965,7 +2973,7 @@ declare global {
       'A blazingly fast WebAssembly solver that supports most rules and symbols (including underclued).';
     protected createWorker(): Worker;
     isGridSupported(grid: GridData): boolean;
-    isInstructionSupported(instructionId: string): boolean;
+    isInstructionSupported(grid: GridData, instruction: Instruction): boolean;
     isEnvironmentSupported(): Promise<boolean>;
   }
   export declare function gridToJson(grid: GridData): PuzzleData$1;
@@ -2975,101 +2983,6 @@ declare global {
     readonly description =
       'A backtracking solver that supports all rules and symbols (including underclued) but is less optimized.';
     protected createWorker(): Worker;
-    isInstructionSupported(instructionId: string): boolean;
-  }
-  export declare class Z3SolverContext<
-    Name extends string,
-    const Core extends Solver$1<Name> | Optimize<Name> =
-      | Solver$1<Name>
-      | Optimize<Name>,
-  > {
-    readonly grid: SymbolGrid<Name, Core>;
-    private _regionConstrainer;
-    constructor(grid: SymbolGrid<Name, Core>);
-    get solver(): Core;
-    get lattice(): import('grilops').Lattice;
-    get symbolSet(): import('grilops').SymbolSet;
-    get ctx(): import('z3-solver').Context<Name>;
-    get z3(): Z3LowLevel['Z3'];
-    get regionConstrainer(): RegionConstrainer<Name, Core>;
-  }
-  export declare abstract class Z3Module {
-    abstract get id(): string;
-    abstract encode<Name extends string>(
-      grid: GridData,
-      ctx: Z3SolverContext<Name>
-    ): void;
-  }
-  export declare class AreaNumberModule extends Z3Module {
-    readonly id: string;
-    encode<Name extends string>(
-      grid: GridData,
-      ctx: Z3SolverContext<Name, Solver$1<Name> | Optimize<Name>>
-    ): void;
-  }
-  export declare class CellCountModule extends Z3Module {
-    readonly id: string;
-    encode<Name extends string>(
-      grid: GridData,
-      ctx: Z3SolverContext<Name, Solver$1<Name> | Optimize<Name>>
-    ): void;
-  }
-  export declare class ConnectAllModule extends Z3Module {
-    readonly id: string;
-    encode<Name extends string>(
-      grid: GridData,
-      ctx: Z3SolverContext<Name, Solver$1<Name> | Optimize<Name>>
-    ): void;
-  }
-  export declare class DartModule extends Z3Module {
-    readonly id: string;
-    encode<Name extends string>(
-      grid: GridData,
-      ctx: Z3SolverContext<Name, Solver$1<Name> | Optimize<Name>>
-    ): void;
-  }
-  export declare const allZ3Modules: Map<string, Z3Module>;
-  export declare class LetterModule extends Z3Module {
-    readonly id: string;
-    encode<Name extends string>(
-      grid: GridData,
-      ctx: Z3SolverContext<Name, Solver$1<Name> | Optimize<Name>>
-    ): void;
-  }
-  export declare class MyopiaModule extends Z3Module {
-    readonly id: string;
-    encode<Name extends string>(
-      grid: GridData,
-      ctx: Z3SolverContext<Name, Solver$1<Name> | Optimize<Name>>
-    ): void;
-  }
-  export declare class RegionAreaModule extends Z3Module {
-    readonly id: string;
-    encode<Name extends string>(
-      grid: GridData,
-      ctx: Z3SolverContext<Name, Solver$1<Name> | Optimize<Name>>
-    ): void;
-  }
-  export declare class ViewpointModule extends Z3Module {
-    readonly id: string;
-    encode<Name extends string>(
-      grid: GridData,
-      ctx: Z3SolverContext<Name, Solver$1<Name> | Optimize<Name>>
-    ): void;
-  }
-  export declare function convertDirection(
-    direction: Orientation | Direction
-  ): import('grilops').Direction;
-  export declare class Z3Solver extends Solver {
-    readonly id = 'z3';
-    readonly author = 'Lysine';
-    readonly description =
-      '(Obsolete) A WebAssembly solver that supports a limited set of rules and symbols.';
-    readonly supportsCancellation = false;
-    protected isEnvironmentSupported(): Promise<boolean>;
-    solve(grid: GridData): AsyncGenerator<GridData | null>;
-    isInstructionSupported(instructionId: string): boolean;
-    isGridSupported(grid: GridData): boolean;
   }
   export declare abstract class CustomSymbol
     extends Symbol$1
@@ -3281,7 +3194,7 @@ declare global {
     countTiles(grid: GridData): {
       completed: number;
       possible: number;
-    };
+    } | null;
     copyWith({
       x,
       y,

package/dist/src/data/grid.d.ts

@@ -10,6 +10,7 @@ import UndercluedRule from './rules/undercluedRule.js';
 import GridZones from './gridZones.js';
 import WrapAroundRule from './rules/wrapAroundRule.js';
 export declare const NEIGHBOR_OFFSETS: Position[];
+export declare const NEIGHBOR_OFFSETS_8: Position[];
 export default class GridData {
     readonly width: number;
     readonly height: number;

package/dist/src/data/grid.js

@@ -12,6 +12,16 @@ export const NEIGHBOR_OFFSETS = [
     { x: 0, y: -1 },
     { x: 0, y: 1 },
 ];
+export const NEIGHBOR_OFFSETS_8 = [
+    { x: -1, y: 0 },
+    { x: 1, y: 0 },
+    { x: 0, y: -1 },
+    { x: 0, y: 1 },
+    { x: -1, y: -1 },
+    { x: 1, y: -1 },
+    { x: -1, y: 1 },
+    { x: 1, y: 1 },
+];
 export default class GridData {
     width;
     height;

package/dist/src/data/rules/noLoopsRule.js

@@ -1,5 +1,5 @@
 import { ConfigType } from '../config.js';
-import GridData, { NEIGHBOR_OFFSETS } from '../grid.js';
+import GridData, { NEIGHBOR_OFFSETS, NEIGHBOR_OFFSETS_8 } from '../grid.js';
 import { array } from '../dataHelper.js';
 import { Color, State } from '../primitives.js';
 import Rule from './rule.js';
@@ -60,48 +60,152 @@ export default class NoLoopsRule extends Rule {
         return NoLoopsRule.SEARCH_VARIANTS;
     }
     validateGrid(grid) {
+        // wrap-around grids require special consideration because the "islands" assumption of the
+        // algorithm below does not hold
+        if (grid.wrapAround.value) {
+            const visited = array(grid.width, grid.height, (i, j) => {
+                const tile = grid.getTile(i, j);
+                return (!tile.exists ||
+                    (tile.color !== this.color && tile.color !== Color.Gray));
+            });
+            while (true) {
+                const seed = grid.find((tile, x, y) => !visited[y][x] && tile.color === this.color);
+                if (!seed)
+                    break;
+                let invalid = false;
+                const positions = [];
+                const stack = [[seed, null]];
+                while (stack.length > 0) {
+                    const [{ x, y }, from] = stack.pop();
+                    const { x: arrX, y: arrY } = grid.toArrayCoordinates(x, y);
+                    positions.push({ x: arrX, y: arrY });
+                    if (visited[arrY][arrX]) {
+                        invalid = true;
+                        continue;
+                    }
+                    visited[arrY][arrX] = true;
+                    for (const offset of NEIGHBOR_OFFSETS) {
+                        if (-offset.x === from?.x && -offset.y === from?.y)
+                            continue;
+                        const next = { x: x + offset.x, y: y + offset.y };
+                        if (grid.isPositionValid(next.x, next.y)) {
+                            const nextTile = grid.getTile(next.x, next.y);
+                            if (nextTile.exists && nextTile.color === this.color)
+                                stack.push([next, offset]);
+                        }
+                    }
+                }
+                if (invalid) {
+                    return {
+                        state: State.Error,
+                        positions,
+                    };
+                }
+            }
+            return {
+                state: visited.some(row => row.some(v => !v))
+                    ? State.Incomplete
+                    : State.Satisfied,
+            };
+        }
+        // special handling for 2x2 loops
+        for (let y = 0; y < grid.height; y++) {
+            for (let x = 0; x < grid.width; x++) {
+                const tlTile = grid.getTile(x, y);
+                const trTile = grid.getTile(x + 1, y);
+                const blTile = grid.getTile(x, y + 1);
+                const brTile = grid.getTile(x + 1, y + 1);
+                if (tlTile.exists &&
+                    tlTile.color === this.color &&
+                    trTile.exists &&
+                    trTile.color === this.color &&
+                    blTile.exists &&
+                    blTile.color === this.color &&
+                    brTile.exists &&
+                    brTile.color === this.color) {
+                    const positions = [
+                        grid.toArrayCoordinates(x, y),
+                        grid.toArrayCoordinates(x + 1, y),
+                        grid.toArrayCoordinates(x, y + 1),
+                        grid.toArrayCoordinates(x + 1, y + 1),
+                    ];
+                    return {
+                        state: State.Error,
+                        positions,
+                    };
+                }
+            }
+        }
+        // general case for non-wrap-around grids: a loop must form an elcosed island that does not touch the grid edge
         const visited = array(grid.width, grid.height, (i, j) => {
             const tile = grid.getTile(i, j);
-            return (!tile.exists || (tile.color !== this.color && tile.color !== Color.Gray));
+            return tile.exists && tile.color === this.color;
         });
+        const shape = array(grid.width, grid.height, () => false);
+        let complete = true;
         while (true) {
-            const seed = grid.find((tile, x, y) => !visited[y][x] && tile.color === this.color);
+            const seed = grid.find((tile, x, y) => !visited[y][x] && (!tile.exists || tile.color !== this.color));
+            shape.forEach(row => row.fill(false));
             if (!seed)
                 break;
-            let invalid = false;
-            const positions = [];
-            const stack = [[seed, null]];
+            let isIsland = true;
+            const stack = [seed];
             while (stack.length > 0) {
-                const [{ x, y }, from] = stack.pop();
+                const { x, y } = stack.pop();
                 const { x: arrX, y: arrY } = grid.toArrayCoordinates(x, y);
-                positions.push({ x, y });
+                const tile = grid.getTile(x, y);
+                if (tile.exists && tile.color === Color.Gray) {
+                    complete = false;
+                }
                 if (visited[arrY][arrX]) {
-                    invalid = true;
                     continue;
                 }
                 visited[arrY][arrX] = true;
-                for (const offset of NEIGHBOR_OFFSETS) {
-                    if (-offset.x === from?.x && -offset.y === from?.y)
-                        continue;
+                for (const offset of NEIGHBOR_OFFSETS_8) {
                     const next = { x: x + offset.x, y: y + offset.y };
+                    const arrPos = grid.toArrayCoordinates(next.x, next.y);
                     if (grid.isPositionValid(next.x, next.y)) {
                         const nextTile = grid.getTile(next.x, next.y);
-                        if (nextTile.exists && nextTile.color === this.color)
-                            stack.push([next, offset]);
+                        shape[arrPos.y][arrPos.x] = true;
+                        if (!nextTile.exists || nextTile.color !== this.color) {
+                            stack.push(arrPos);
+                        }
+                    }
+                    else {
+                        isIsland = false;
                     }
                 }
             }
-            if (invalid) {
+            if (isIsland) {
+                const loopPositions = [];
+                for (let y = 0; y < grid.height; y++) {
+                    for (let x = 0; x < grid.width; x++) {
+                        if (shape[y][x]) {
+                            if (x > 0 &&
+                                y > 0 &&
+                                x < grid.width - 1 &&
+                                y < grid.height - 1 &&
+                                shape[y][x - 1] &&
+                                shape[y - 1][x] &&
+                                shape[y][x + 1] &&
+                                shape[y + 1][x] &&
+                                shape[y - 1][x - 1] &&
+                                shape[y - 1][x + 1] &&
+                                shape[y + 1][x - 1] &&
+                                shape[y + 1][x + 1])
+                                continue;
+                            loopPositions.push({ x, y });
+                        }
+                    }
+                }
                 return {
                     state: State.Error,
-                    positions,
+                    positions: loopPositions,
                 };
             }
         }
         return {
-            state: visited.some(row => row.some(v => !v))
-                ? State.Incomplete
-                : State.Satisfied,
+            state: complete ? State.Satisfied : State.Incomplete,
         };
     }
     copyWith({ color }) {

package/dist/src/data/rules/offByXRule.js

@@ -90,6 +90,8 @@ export default class OffByXRule extends Rule {
     onSymbolValidation(grid, symbol, _validator) {
         if (symbol instanceof NumberSymbol) {
             const counts = symbol.countTiles(grid);
+            if (counts === null)
+                return State.Error;
             if (counts.completed > symbol.number + this.number ||
                 counts.possible < symbol.number - this.number ||
                 (counts.completed > symbol.number - this.number &&

package/dist/src/data/solver/allSolvers.js

@@ -1,6 +1,5 @@
 import UniversalSolver from './universal/universalSolver.js';
 import BacktrackSolver from './backtrack/backtrackSolver.js';
-import Z3Solver from './z3/z3Solver.js';
 import CspuzSolver from './cspuz/cspuzSolver.js';
 import AutoSolver from './auto/autoSolver.js';
 const allSolvers = new Map();
@@ -11,5 +10,4 @@ register(new AutoSolver());
 register(new CspuzSolver());
 register(new BacktrackSolver());
 register(new UniversalSolver());
-register(new Z3Solver());
 export { allSolvers };

package/dist/src/data/solver/auto/autoSolver.d.ts

@@ -1,5 +1,6 @@
 import GridData from '../../grid.js';
 import Solver from '../solver.js';
+import Instruction from '../../instruction.js';
 export default class AutoSolver extends Solver {
     readonly id = "auto";
     readonly author = "various contributors";
@@ -7,7 +8,7 @@ export default class AutoSolver extends Solver {
     readonly supportsCancellation = true;
     private static readonly nonAdditiveInstructions;
     isGridSupported(grid: GridData): boolean;
-    isInstructionSupported(instructionId: string): boolean;
+    isInstructionSupported(grid: GridData, instruction: Instruction): boolean;
     protected isEnvironmentSupported(): Promise<boolean>;
     private fillSolution;
     private fixGrid;

package/dist/src/data/solver/auto/autoSolver.js

@@ -1,10 +1,10 @@
 import { Color, State } from '../../primitives.js';
 import { instance as lyingSymbolInstance } from '../../rules/lyingSymbolRule.js';
 import { instance as offByXInstance } from '../../rules/offByXRule.js';
-import { instance as lotusInstance } from '../../symbols/lotusSymbol.js';
-import { instance as galaxyInstance } from '../../symbols/galaxySymbol.js';
 import { instance as wrapAroundInstance } from '../../rules/wrapAroundRule.js';
 import { instance as symbolsPerRegionInstance } from '../../rules/symbolsPerRegionRule.js';
+import { instance as areaNumberInstance } from '../../symbols/areaNumberSymbol.js';
+import { instance as letterInstance } from '../../symbols/letterSymbol.js';
 import { allSolvers } from '../allSolvers.js';
 import Solver from '../solver.js';
 import UndercluedRule from '../../rules/undercluedRule.js';
@@ -30,11 +30,11 @@ export default class AutoSolver extends Solver {
         }
         return false;
     }
-    isInstructionSupported(instructionId) {
+    isInstructionSupported(grid, instruction) {
         for (const solver of allSolvers.values()) {
             if (solver.id === this.id)
                 continue;
-            if (solver.isInstructionSupported(instructionId)) {
+            if (solver.isInstructionSupported(grid, instruction)) {
                 return true;
             }
         }
@@ -113,24 +113,20 @@ export default class AutoSolver extends Solver {
                     return;
                 }
                 else {
-                    let undercluedGrid = progressGrid
-                        .withRules(rules => rules.filter(r => solver.isInstructionSupported(r.id)))
+                    const undercluedGrid = progressGrid
+                        .withRules(rules => rules.filter(r => solver.isInstructionSupported(progressGrid, r)))
                         .withSymbols(symbols => {
-                        for (const id of symbols.keys()) {
-                            if (!solver.isInstructionSupported(id))
-                                symbols.delete(id);
+                        for (const [id, symbolList] of symbols.entries()) {
+                            symbols.set(id, symbolList.filter(symbol => 
+                            // special handling: do not delete area number and letter symbols as they can be solved
+                            // underclued even if the solver doesn't fully support them
+                            symbol.id === areaNumberInstance.id ||
+                                symbol.id === letterInstance.id ||
+                                solver.isInstructionSupported(progressGrid, symbol)));
                         }
                         return symbols;
                     })
                         .addRule(new UndercluedRule());
-                    if (!solver.isGridSupported(undercluedGrid)) {
-                        // special case for solvers that support lotus and galaxy symbols but not dual-color placement
-                        undercluedGrid = undercluedGrid.withSymbols(symbols => {
-                            symbols.delete(lotusInstance.id);
-                            symbols.delete(galaxyInstance.id);
-                            return symbols;
-                        });
-                    }
                     if (!solver.isGridSupported(undercluedGrid))
                         continue;
                     const undercluedSolution = await this.solveOne(this.solveWithProgress(solver, progressGrid, undercluedGrid, abortSignal));

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

@@ -1,9 +1,11 @@
 import EventIteratingSolver from '../eventIteratingSolver.js';
+import Instruction from '../../instruction.js';
+import GridData from '../../grid.js';
 export default class BacktrackSolver extends EventIteratingSolver {
     private static readonly supportedInstrs;
     readonly id = "backtrack";
     readonly author = "ALaggyDev";
     readonly description = "Solves puzzles pretty fast using backtracking with optimizations. Support most rules and symbols (including underclued).";
     protected createWorker(): Worker;
-    isInstructionSupported(instructionId: string): boolean;
+    isInstructionSupported(_grid: GridData, instruction: Instruction): boolean;
 }

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

@@ -46,7 +46,7 @@ export default class BacktrackSolver extends EventIteratingSolver {
             type: 'module',
         });
     }
-    isInstructionSupported(instructionId) {
-        return BacktrackSolver.supportedInstrs.includes(instructionId);
+    isInstructionSupported(_grid, instruction) {
+        return BacktrackSolver.supportedInstrs.includes(instruction.id);
     }
 }

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

@@ -2,6 +2,7 @@ import { array } from '../../dataHelper.js';
 import { Color } from '../../primitives.js';
 import { instance as banPatternInstance, } from '../../rules/banPatternRule.js';
 import { instance as cellCountInstance, } from '../../rules/cellCountRule.js';
+import { instance as connectAllInstance, } from '../../rules/connectAllRule.js';
 import { instance as regionAreaInstance, } from '../../rules/regionAreaRule.js';
 import { instance as sameShapeInstance, } from '../../rules/sameShapeRule.js';
 import { instance as symbolsPerRegionInstance, } from '../../rules/symbolsPerRegionRule.js';
@@ -17,7 +18,6 @@ import { instance as minesweeperInstance, } from '../../symbols/minesweeperSymbo
 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';
 import { BTGridData, BTTile } from './data.js';
 import BanPatternBTModule from './rules/banPattern.js';
 import CellCountBTModule from './rules/cellCount.js';
@@ -104,7 +104,7 @@ function translateToBTGridData(grid) {
         }
         else if (rule.id === symbolsPerRegionInstance.id) {
             const allSymbols = [];
-            grid.symbols.forEach(symbols => allSymbols.push(...symbols));
+            grid.symbols.forEach(symbols => allSymbols.push(...symbols.filter(symbol => symbol.necessaryForCompletion)));
             module = new SymbolsPerRegionBTModule(rule, grid.width, grid.height, allSymbols);
         }
         else if (rule.id === cellCountInstance.id) {

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

@@ -44,3 +44,4 @@ export default abstract class BTModule {
 export declare function getOppositeColor(color: BTColor): BTColor;
 export declare function colorToBTTile(color: Color): BTTile;
 export declare function createOneTileResult(grid: BTGridData, pos: Position, score?: number | undefined): CheckResult;
+export declare function checkSubtilePlacement(grid: BTGridData, pos: Position): CheckResult | false | undefined;

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

@@ -106,3 +106,46 @@ export function createOneTileResult(grid, pos, score = 1) {
     const ratings = [{ pos, score }];
     return { tilesNeedCheck, ratings };
 }
+export function checkSubtilePlacement(grid, pos) {
+    const minX = Math.floor(pos.x);
+    const minY = Math.floor(pos.y);
+    if (minX === pos.x && minY === pos.y)
+        return undefined;
+    const maxX = Math.ceil(pos.x);
+    const maxY = Math.ceil(pos.y);
+    let color = null;
+    let complete = true;
+    for (let i = 0; i < 4; i++) {
+        const x = i % 2 === 0 ? minX : maxX;
+        const y = i < 2 ? minY : maxY;
+        if (!grid.isInBound(x, y))
+            return false;
+        const tile = grid.getTile(x, y);
+        if (tile === BTTile.NonExist)
+            return false;
+        if (tile !== BTTile.Empty) {
+            if (color !== null && tile !== color)
+                return false;
+            color = tile;
+        }
+        else {
+            complete = false;
+        }
+    }
+    if (complete) {
+        return undefined;
+    }
+    else {
+        const tilesNeedCheck = IntArray2D.create(grid.width, grid.height);
+        const ratings = [];
+        for (let i = 0; i < 4; i++) {
+            const x = i % 2 === 0 ? minX : maxX;
+            const y = i < 2 ? minY : maxY;
+            if (grid.getTile(x, y) === BTTile.Empty) {
+                tilesNeedCheck.set(x, y, 1);
+                ratings.push({ pos: { x, y }, score: 1 });
+            }
+        }
+        return { tilesNeedCheck, ratings };
+    }
+}

package/dist/src/data/solver/backtrack/symbols/areaNumber.js

@@ -1,4 +1,4 @@
-import BTModule, { BTTile, IntArray2D, createOneTileResult, } from '../data.js';
+import BTModule, { BTTile, checkSubtilePlacement, IntArray2D, createOneTileResult, } from '../data.js';
 export default class AreaNumberBTModule extends BTModule {
     instr;
     constructor(instr) {
@@ -6,6 +6,9 @@ export default class AreaNumberBTModule extends BTModule {
         this.instr = instr;
     }
     checkGlobal(grid) {
+        const checkResult = checkSubtilePlacement(grid, this.instr);
+        if (checkResult !== undefined)
+            return checkResult;
         const thisX = Math.floor(this.instr.x);
         const thisY = Math.floor(this.instr.y);
         const tile = grid.getTile(thisX, thisY);

package/dist/src/data/solver/backtrack/symbols/letter.js

@@ -1,4 +1,4 @@
-import BTModule, { BTTile, IntArray2D, } from '../data.js';
+import BTModule, { BTTile, checkSubtilePlacement, IntArray2D, } from '../data.js';
 export default class LetterBTModule extends BTModule {
     letters;
     letterGrid;
@@ -23,6 +23,9 @@ export default class LetterBTModule extends BTModule {
         const visited = IntArray2D.create(grid.width, grid.height);
         for (let id = 0; id < this.letters.length; id++) {
             for (const symbol of this.letters[id]) {
+                const checkResult = checkSubtilePlacement(grid, symbol);
+                if (checkResult !== undefined)
+                    return checkResult;
                 const symbolX = Math.floor(symbol.x);
                 const symbolY = Math.floor(symbol.y);
                 if (grid.getTile(symbolX, symbolY) === BTTile.Empty)

package/dist/src/data/solver/cspuz/cspuzSolver.d.ts

@@ -1,5 +1,6 @@
 import EventIteratingSolver from '../eventIteratingSolver.js';
 import GridData from '../../grid.js';
+import Instruction from '../../instruction.js';
 export default class CspuzSolver extends EventIteratingSolver {
     private static readonly supportedInstrs;
     readonly id = "cspuz";
@@ -7,6 +8,6 @@ export default class CspuzSolver extends EventIteratingSolver {
     readonly description = "A blazingly fast WebAssembly solver that supports most rules and symbols (including underclued).";
     protected createWorker(): Worker;
     isGridSupported(grid: GridData): boolean;
-    isInstructionSupported(instructionId: string): boolean;
+    isInstructionSupported(grid: GridData, instruction: Instruction): boolean;
     isEnvironmentSupported(): Promise<boolean>;
 }