@logic-pad/core 0.25.3 → 0.26.1

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;
@@ -2388,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.
@@ -2410,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;
@@ -2437,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,
@@ -2494,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);
@@ -2555,7 +2562,7 @@ declare global {
     abstract countTiles(grid: GridData): {
       completed: number;
       possible: number;
-    };
+    } | null;
     validateSymbol(grid: GridData): State;
     withNumber(number: number): this;
   }
@@ -2578,7 +2585,7 @@ declare global {
     countTiles(grid: GridData): {
       completed: number;
       possible: number;
-    };
+    } | null;
     copyWith({
       x,
       y,
@@ -2966,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;
@@ -2976,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
@@ -3282,7 +3194,7 @@ declare global {
     countTiles(grid: GridData): {
       completed: number;
       possible: number;
-    };
+    } | null;
     copyWith({
       x,
       y,
@@ -3294,6 +3206,21 @@ declare global {
     }): this;
   }
   export declare const allSymbols: Map<string, Symbol$1>;
+  /**
+   * A marker for symbols not supported by the current solver.
+   * Solvers should count these symbols in the symbols per region rule but otherwise ignore them.
+   */
+  export declare class UnsupportedSymbol extends Symbol$1 {
+    readonly title = 'Unsupported Symbol';
+    private static readonly CONFIGS;
+    private static readonly EXAMPLE_GRID;
+    get id(): string;
+    get explanation(): string;
+    get configs(): readonly AnyConfig[] | null;
+    createExampleGrid(): GridData;
+    validateSymbol(_grid: GridData, _solution: GridData | null): State;
+    copyWith({ x, y }: { x?: number; y?: number }): this;
+  }
   export declare function aggregateState(
     rules: readonly RuleState[],
     grid: GridData,

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,14 +1,14 @@
 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';
 import validateGrid from '../../validate.js';
+import UnsupportedSymbol from '../../symbols/unsupportedSymbol.js';
 export default class AutoSolver extends Solver {
     id = 'auto';
     author = 'various contributors';
@@ -18,7 +18,6 @@ export default class AutoSolver extends Solver {
         offByXInstance.id,
         lyingSymbolInstance.id,
         wrapAroundInstance.id,
-        symbolsPerRegionInstance.id,
     ]);
     isGridSupported(grid) {
         for (const solver of allSolvers.values()) {
@@ -30,11 +29,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 +112,24 @@ 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.map(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
+                                if (symbol.id === areaNumberInstance.id ||
+                                    symbol.id === letterInstance.id)
+                                    return symbol;
+                                if (solver.isInstructionSupported(progressGrid, symbol))
+                                    return symbol;
+                                return new UnsupportedSymbol(symbol.x, symbol.y);
+                            }));
                         }
                         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

@@ -15,6 +15,7 @@ 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 '../../rules/connectAllRule.js';
+import { instance as unsupportedInstance } from '../../symbols/unsupportedSymbol.js';
 import EventIteratingSolver from '../eventIteratingSolver.js';
 // eslint-disable-next-line @typescript-eslint/no-unused-expressions
 ('vite-apply-code-mod');
@@ -37,6 +38,7 @@ export default class BacktrackSolver extends EventIteratingSolver {
         cellCountInstance.id,
         sameShapeInstance.id,
         uniqueShapeInstance.id,
+        unsupportedInstance.id,
     ];
     id = 'backtrack';
     author = 'ALaggyDev';
@@ -46,7 +48,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,7 @@ 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 { instance as unsupportedInstance } from '../../symbols/unsupportedSymbol.js';
 import { BTGridData, BTTile } from './data.js';
 import BanPatternBTModule from './rules/banPattern.js';
 import CellCountBTModule from './rules/cellCount.js';
@@ -79,6 +80,9 @@ function translateToBTGridData(grid) {
             else if (id === letterInstance.id) {
                 continue;
             }
+            else if (id === unsupportedInstance.id) {
+                continue;
+            }
             if (!module && symbol.necessaryForCompletion)
                 throw new Error('Symbol not supported.');
             if (module)
@@ -104,7 +108,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;
@@ -22,6 +22,11 @@ export default class LetterBTModule extends BTModule {
     checkGlobal(grid) {
         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;
+            }
             for (const symbol of this.letters[id]) {
                 const symbolX = Math.floor(symbol.x);
                 const symbolY = Math.floor(symbol.y);

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>;
 }

package/dist/src/data/solver/cspuz/cspuzSolver.js

@@ -6,14 +6,15 @@ import { instance as symbolsPerRegionInstance } from '../../rules/symbolsPerRegi
 import { instance as undercluedInstance } from '../../rules/undercluedRule.js';
 import { instance as uniqueShapeInstance } from '../../rules/uniqueShapeRule.js';
 import { instance as offByXInstance } from '../../rules/offByXRule.js';
-import { instance as areaNumberInstance } from '../../symbols/areaNumberSymbol.js';
+import AreaNumberSymbol, { instance as areaNumberInstance, } from '../../symbols/areaNumberSymbol.js';
 import { instance as dartInstance } from '../../symbols/dartSymbol.js';
 import GalaxySymbol, { instance as galaxyInstance, } from '../../symbols/galaxySymbol.js';
-import { instance as letterInstance } from '../../symbols/letterSymbol.js';
+import LetterSymbol, { instance as letterInstance, } from '../../symbols/letterSymbol.js';
 import LotusSymbol, { instance as lotusInstance, } from '../../symbols/lotusSymbol.js';
 import { instance as minesweeperInstance } from '../../symbols/minesweeperSymbol.js';
 import { instance as viewpointInstance } from '../../symbols/viewpointSymbol.js';
 import { instance as connectAllInstance } from '../../rules/connectAllRule.js';
+import { instance as unsupportedInstance } from '../../symbols/unsupportedSymbol.js';
 import EventIteratingSolver from '../eventIteratingSolver.js';
 import GridData from '../../grid.js';
 import { Color } from '../../primitives.js';
@@ -37,6 +38,7 @@ export default class CspuzSolver extends EventIteratingSolver {
         offByXInstance.id,
         undercluedInstance.id,
         symbolsPerRegionInstance.id,
+        unsupportedInstance.id,
     ];
     id = 'cspuz';
     author = 'semiexp';
@@ -50,31 +52,63 @@ export default class CspuzSolver extends EventIteratingSolver {
         if (!super.isGridSupported(grid)) {
             return false;
         }
-        // special handling for galaxies and lotuses since dual-color symbols are not supported yet
-        for (const [_, symbols] of grid.symbols) {
-            for (const symbol of symbols) {
-                if (symbol instanceof GalaxySymbol || symbol instanceof LotusSymbol) {
-                    if (symbol.x % 1 !== 0 && symbol.y % 1 !== 0) {
+        // special handling for fixed gray tiles
+        if (grid.getTileCount(true, true, Color.Gray) > 0) {
+            return false;
+        }
+        // the solver doesn't count symbols correctly if some symbols are unsupported
+        if (grid.findSymbol(symbol => symbol.id === unsupportedInstance.id) &&
+            grid.findRule(rule => rule.id === symbolsPerRegionInstance.id)) {
+            return false;
+        }
+        return true;
+    }
+    isInstructionSupported(grid, instruction) {
+        if (instruction instanceof LotusSymbol ||
+            instruction instanceof GalaxySymbol) {
+            if (instruction.x % 1 !== 0 && instruction.y % 1 !== 0) {
+                return false;
+            }
+        }
+        if (instruction instanceof LotusSymbol ||
+            instruction instanceof GalaxySymbol ||
+            instruction instanceof AreaNumberSymbol ||
+            instruction instanceof LetterSymbol) {
+            if (instruction.x % 1 !== 0 || instruction.y % 1 !== 0) {
+                const minX = Math.floor(instruction.x);
+                const minY = Math.floor(instruction.y);
+                const maxX = Math.ceil(instruction.x);
+                const maxY = Math.ceil(instruction.y);
+                const connectedTiles = grid.connections.getConnectedTiles({
+                    x: minX,
+                    y: minY,
+                });
+                if (connectedTiles.some(tile => tile.x === minX && tile.y === maxY) &&
+                    connectedTiles.some(tile => tile.x === maxX && tile.y === minY) &&
+                    connectedTiles.some(tile => tile.x === maxX && tile.y === maxY)) {
+                    return true;
+                }
+                let color = Color.Gray;
+                for (let i = 0; i < 4; i++) {
+                    const x = i % 2 === 0 ? minX : maxX;
+                    const y = i < 2 ? minY : maxY;
+                    const tile = grid.getTile(x, y);
+                    if (!tile.fixed || !tile.exists) {
                         return false;
                     }
-                    else if (symbol.x % 1 !== 0 || symbol.y % 1 !== 0) {
-                        const tile1 = grid.getTile(Math.floor(symbol.x), Math.floor(symbol.y));
-                        const tile2 = grid.getTile(Math.ceil(symbol.x), Math.ceil(symbol.y));
-                        if (!tile1.fixed || !tile2.fixed || tile1.color !== tile2.color) {
+                    if (tile.color !== Color.Gray) {
+                        if (color === Color.Gray) {
+                            color = tile.color;
+                        }
+                        else if (color !== tile.color) {
                             return false;
                         }
                     }
                 }
+                return true;
             }
         }
-        // special handling for fixed gray tiles
-        if (grid.getTileCount(true, true, Color.Gray) > 0) {
-            return false;
-        }
-        return true;
-    }
-    isInstructionSupported(instructionId) {
-        return CspuzSolver.supportedInstrs.includes(instructionId);
+        return CspuzSolver.supportedInstrs.includes(instruction.id);
     }
     async isEnvironmentSupported() {
         try {

package/dist/src/data/solver/cspuz/jsonify.js

@@ -15,6 +15,7 @@ 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 viewpointInstance, } from '../../symbols/viewpointSymbol.js';
+import { instance as unsupportedInstance } from '../../symbols/unsupportedSymbol.js';
 import TileData from '../../tile.js';
 function canonizeTiles(tileData) {
     const ret = [];
@@ -180,6 +181,9 @@ export function gridToJson(grid) {
                 tiles,
             });
         }
+        else if (rule === unsupportedInstance.id) {
+            continue;
+        }
         else if (symbols.some(s => s.necessaryForCompletion)) {
             throw new Error(`Unknown symbol type: ${rule}`);
         }

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

@@ -1,5 +1,6 @@
 import { CachedAccess } from '../dataHelper.js';
 import GridData from '../grid.js';
+import { Instruction } from '../../index.js';
 /**
  * Base class that all solvers must extend.
  */
@@ -61,7 +62,7 @@ export default abstract class Solver {
      *
      * @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.