@logic-pad/core 0.2.1 → 0.3.0

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

@@ -401,7 +401,11 @@ declare global {
     val: T
   ): val is T & GridChangeHandler;
   export interface SetGridHandler {
-    onSetGrid(oldGrid: GridData, newGrid: GridData): GridData;
+    onSetGrid(
+      oldGrid: GridData,
+      newGrid: GridData,
+      solution: GridData | null
+    ): GridData;
   }
   export declare function handlesSetGrid<T extends Instruction>(
     val: T
@@ -504,7 +508,11 @@ declare global {
     createExampleGrid(): GridData;
     get searchVariants(): SearchVariant[];
     validateGrid(_grid: GridData): RuleState;
-    onSetGrid(_oldGrid: GridData, newGrid: GridData): GridData;
+    onSetGrid(
+      _oldGrid: GridData,
+      newGrid: GridData,
+      _solution: GridData | null
+    ): GridData;
     onGridChange(newGrid: GridData): this;
     onGridResize(
       _grid: GridData,
@@ -944,6 +952,14 @@ declare global {
      * @returns True if the grids are equal in size and tile colors, false otherwise.
      */
     colorEquals(grid: GridData): boolean;
+    /**
+     * Check if this grid conforms to the given solution, or an incomplete version of the solution.
+     * Symbols and rules are not validated.
+     *
+     * @param solution The solution to compare with.
+     * @returns True if the grid conforms to the solution, false otherwise.
+     */
+    solutionMatches(solution: GridData): boolean;
     /**
      * Check if this grid is equal to another grid in terms of size, tile colors, connections, symbols, and rules.
      *
@@ -1014,6 +1030,7 @@ declare global {
     Icon = 'icon',
     ControlLines = 'controlLines',
     NullableNote = 'nullableNote',
+    SolvePath = 'solvePath',
   }
   export interface Config<T> {
     readonly type: ConfigType;
@@ -1084,6 +1101,9 @@ declare global {
   export interface NullableNoteConfig extends Config<string | null> {
     readonly type: ConfigType.NullableNote;
   }
+  export interface SolvePathConfig extends Config<Position$1[]> {
+    readonly type: ConfigType.SolvePath;
+  }
   export type AnyConfig =
     | BooleanConfig
     | NullableBooleanConfig
@@ -1101,7 +1121,8 @@ declare global {
     | NullableGridConfig
     | IconConfig
     | ControlLinesConfig
-    | NullableNoteConfig;
+    | NullableNoteConfig
+    | SolvePathConfig;
   /**
    * Compare two config values for equality, using an appropriate method for the config type.
    *
@@ -1390,13 +1411,19 @@ declare global {
     readonly count: number;
     readonly regenInterval: number;
     readonly startFull: boolean;
+    readonly solvePath: Position$1[];
     private static readonly EXAMPLE_GRID;
     private static readonly CONFIGS;
     private static readonly SEARCH_VARIANTS;
     /**
      * **Foresight: Show hints**
      */
-    constructor(count: number, regenInterval: number, startFull: boolean);
+    constructor(
+      count: number,
+      regenInterval: number,
+      startFull: boolean,
+      solvePath?: Position$1[]
+    );
     get id(): string;
     get explanation(): string;
     get visibleWhenSolving(): boolean;
@@ -1410,10 +1437,12 @@ declare global {
       count,
       regenInterval,
       startFull,
+      solvePath,
     }: {
       count?: number;
       regenInterval?: number;
       startFull?: boolean;
+      solvePath?: Position$1[];
     }): this;
   }
   export declare const allRules: Map<string, Rule>;
@@ -1490,6 +1519,45 @@ declare global {
     copyWith({ number }: { number?: number }): this;
     withNumber(number: number): this;
   }
+  export declare class PerfectionRule
+    extends Rule
+    implements SetGridHandler, FinalValidationHandler
+  {
+    private static readonly EXAMPLE_GRID;
+    private static readonly SEARCH_VARIANTS;
+    /**
+     * **Quest for Perfection: cell colors are final**
+     */
+    constructor();
+    get id(): string;
+    get explanation(): string;
+    get configs(): readonly AnyConfig[] | null;
+    createExampleGrid(): GridData;
+    get searchVariants(): SearchVariant[];
+    get necessaryForCompletion(): boolean;
+    get isSingleton(): boolean;
+    validateGrid(grid: GridData): RuleState;
+    /**
+     * If the grid passes validation but is different from the solution, indicate the error in the final state.
+     */
+    onFinalValidation(
+      grid: GridData,
+      solution: GridData | null,
+      state: GridState
+    ): GridState;
+    private fixTiles;
+    /**
+     * Force all tiles to be fixed.
+     *
+     * If the grid is already wrong, prevent the player from changing it further.
+     */
+    onSetGrid(
+      oldGrid: GridData,
+      newGrid: GridData,
+      solution: GridData | null
+    ): GridData;
+    copyWith(_: object): this;
+  }
   export declare class RegionAreaRule extends Rule {
     readonly color: Color;
     readonly size: number;
@@ -2011,7 +2079,6 @@ declare global {
     get explanation(): string;
     get configs(): readonly AnyConfig[] | null;
     createExampleGrid(): GridData;
-    private getColor;
     private deltaCoordinate;
     validateSymbol(grid: GridData): State;
     copyWith({ x, y }: { x?: number; y?: number }): this;
@@ -2020,6 +2087,8 @@ declare global {
   export declare abstract class DirectionLinkerBTModule extends BTModule {
     instr: DirectionLinkerSymbol;
     constructor(instr: DirectionLinkerSymbol);
+    private initialPositions;
+    private getInitialPositions;
     checkGlobal(grid: BTGridData): CheckResult | false;
     protected abstract movePos(
       grid: BTGridData,
@@ -2127,6 +2196,8 @@ declare global {
       x: number,
       y: number
     ): Position$1 | null;
+    private getTileSafe;
+    checkGlobal(grid: BTGridData): false | CheckResult;
   }
   export declare class MinesweeperSymbol extends NumberSymbol {
     private static readonly CONFIGS;

package/dist/data/config.d.ts

@@ -1,5 +1,5 @@
 import GridData from './grid.js';
-import { Color, Comparison, Direction, DirectionToggle, Orientation, OrientationToggle } from './primitives.js';
+import { Color, Comparison, Direction, DirectionToggle, Orientation, OrientationToggle, Position } from './primitives.js';
 import { ControlLine } from './rules/musicControlLine.js';
 export declare enum ConfigType {
     Boolean = "boolean",
@@ -18,7 +18,8 @@ export declare enum ConfigType {
     NullableGrid = "nullableGrid",
     Icon = "icon",
     ControlLines = "controlLines",
-    NullableNote = "nullableNote"
+    NullableNote = "nullableNote",
+    SolvePath = "solvePath"
 }
 export interface Config<T> {
     readonly type: ConfigType;
@@ -89,7 +90,10 @@ export interface ControlLinesConfig extends Config<ControlLine[]> {
 export interface NullableNoteConfig extends Config<string | null> {
     readonly type: ConfigType.NullableNote;
 }
-export type AnyConfig = BooleanConfig | NullableBooleanConfig | NumberConfig | NullableNumberConfig | StringConfig | ColorConfig | ComparisonConfig | DirectionConfig | DirectionToggleConfig | OrientationConfig | OrientationToggleConfig | TileConfig | GridConfig | NullableGridConfig | IconConfig | ControlLinesConfig | NullableNoteConfig;
+export interface SolvePathConfig extends Config<Position[]> {
+    readonly type: ConfigType.SolvePath;
+}
+export type AnyConfig = BooleanConfig | NullableBooleanConfig | NumberConfig | NullableNumberConfig | StringConfig | ColorConfig | ComparisonConfig | DirectionConfig | DirectionToggleConfig | OrientationConfig | OrientationToggleConfig | TileConfig | GridConfig | NullableGridConfig | IconConfig | ControlLinesConfig | NullableNoteConfig | SolvePathConfig;
 /**
  * Compare two config values for equality, using an appropriate method for the config type.
  *

package/dist/data/config.js

@@ -18,6 +18,7 @@ export var ConfigType;
     ConfigType["Icon"] = "icon";
     ConfigType["ControlLines"] = "controlLines";
     ConfigType["NullableNote"] = "nullableNote";
+    ConfigType["SolvePath"] = "solvePath";
 })(ConfigType || (ConfigType = {}));
 /**
  * Compare two config values for equality, using an appropriate method for the config type.
@@ -51,5 +52,12 @@ export function configEquals(type, a, b) {
     if (type === ConfigType.OrientationToggle) {
         return ORIENTATIONS.every(dir => a[dir] === b[dir]);
     }
+    if (type === ConfigType.SolvePath) {
+        const aPath = a;
+        const bPath = b;
+        if (aPath.length !== bPath.length)
+            return false;
+        return aPath.every((pos, i) => pos.x === bPath[i].x && pos.y === bPath[i].y);
+    }
     return a === b;
 }

package/dist/data/events/onSetGrid.d.ts

@@ -1,6 +1,6 @@
 import GridData from '../grid.js';
 import Instruction from '../instruction.js';
 export interface SetGridHandler {
-    onSetGrid(oldGrid: GridData, newGrid: GridData): GridData;
+    onSetGrid(oldGrid: GridData, newGrid: GridData, solution: GridData | null): GridData;
 }
 export declare function handlesSetGrid<T extends Instruction>(val: T): val is T & SetGridHandler;

package/dist/data/grid.d.ts

@@ -321,6 +321,14 @@ export default class GridData {
      * @returns True if the grids are equal in size and tile colors, false otherwise.
      */
     colorEquals(grid: GridData): boolean;
+    /**
+     * Check if this grid conforms to the given solution, or an incomplete version of the solution.
+     * Symbols and rules are not validated.
+     *
+     * @param solution The solution to compare with.
+     * @returns True if the grid conforms to the solution, false otherwise.
+     */
+    solutionMatches(solution: GridData): boolean;
     /**
      * Check if this grid is equal to another grid in terms of size, tile colors, connections, symbols, and rules.
      *

package/dist/data/grid.js

@@ -709,13 +709,13 @@ export default class GridData {
         this.symbols.forEach(list => {
             list.forEach(symbol => {
                 if (handlesSetGrid(symbol)) {
-                    newGrid = symbol.onSetGrid(this, newGrid);
+                    newGrid = symbol.onSetGrid(this, newGrid, null);
                 }
             });
         });
         this.rules.forEach(rule => {
             if (handlesSetGrid(rule)) {
-                newGrid = rule.onSetGrid(this, newGrid);
+                newGrid = rule.onSetGrid(this, newGrid, null);
             }
         });
         return newGrid;
@@ -801,6 +801,29 @@ export default class GridData {
             this.tiles.every((row, y) => row.every((tile, x) => (!tile.exists && !grid.getTile(x, y).exists) ||
                 tile.color === grid.getTile(x, y).color)));
     }
+    /**
+     * Check if this grid conforms to the given solution, or an incomplete version of the solution.
+     * Symbols and rules are not validated.
+     *
+     * @param solution The solution to compare with.
+     * @returns True if the grid conforms to the solution, false otherwise.
+     */
+    solutionMatches(solution) {
+        if (this.width !== solution.width)
+            return false;
+        if (this.height !== solution.height)
+            return false;
+        return this.tiles.every((row, y) => row.every((tile, x) => {
+            const solutionTile = solution.getTile(x, y);
+            if (!solutionTile.exists)
+                return true;
+            if (tile.color === Color.Gray)
+                return true;
+            if (solutionTile.color !== tile.color)
+                return false;
+            return true;
+        }));
+    }
     /**
      * Check if this grid is equal to another grid in terms of size, tile colors, connections, symbols, and rules.
      *

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

@@ -1,18 +1,19 @@
 import { AnyConfig } from '../config.js';
 import GridData from '../grid.js';
-import { RuleState } from '../primitives.js';
+import { RuleState, Position } from '../primitives.js';
 import Rule, { SearchVariant } from './rule.js';
 export default class ForesightRule extends Rule {
     readonly count: number;
     readonly regenInterval: number;
     readonly startFull: boolean;
+    readonly solvePath: Position[];
     private static readonly EXAMPLE_GRID;
     private static readonly CONFIGS;
     private static readonly SEARCH_VARIANTS;
     /**
      * **Foresight: Show hints**
      */
-    constructor(count: number, regenInterval: number, startFull: boolean);
+    constructor(count: number, regenInterval: number, startFull: boolean, solvePath?: Position[]);
     get id(): string;
     get explanation(): string;
     get visibleWhenSolving(): boolean;
@@ -22,10 +23,11 @@ export default class ForesightRule extends Rule {
     validateGrid(_grid: GridData): RuleState;
     get necessaryForCompletion(): boolean;
     get isSingleton(): boolean;
-    copyWith({ count, regenInterval, startFull, }: {
+    copyWith({ count, regenInterval, startFull, solvePath, }: {
         count?: number;
         regenInterval?: number;
         startFull?: boolean;
+        solvePath?: Position[];
     }): this;
 }
 export declare const instance: ForesightRule;

package/dist/data/rules/foresightRule.js

@@ -7,7 +7,7 @@ class ForesightRule extends Rule {
     /**
      * **Foresight: Show hints**
      */
-    constructor(count, regenInterval, startFull) {
+    constructor(count, regenInterval, startFull, solvePath = []) {
         super();
         Object.defineProperty(this, "count", {
             enumerable: true,
@@ -27,9 +27,16 @@ class ForesightRule extends Rule {
             writable: true,
             value: startFull
         });
+        Object.defineProperty(this, "solvePath", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: solvePath
+        });
         this.count = count;
         this.regenInterval = regenInterval;
         this.startFull = startFull;
+        this.solvePath = solvePath;
     }
     get id() {
         return `foresight`;
@@ -58,8 +65,8 @@ class ForesightRule extends Rule {
     get isSingleton() {
         return true;
     }
-    copyWith({ count, regenInterval, startFull, }) {
-        return new ForesightRule(count ?? this.count, regenInterval ?? this.regenInterval, startFull ?? this.startFull);
+    copyWith({ count, regenInterval, startFull, solvePath, }) {
+        return new ForesightRule(count ?? this.count, regenInterval ?? this.regenInterval, startFull ?? this.startFull, solvePath ?? this.solvePath);
     }
 }
 Object.defineProperty(ForesightRule, "EXAMPLE_GRID", {
@@ -96,6 +103,13 @@ Object.defineProperty(ForesightRule, "CONFIGS", {
             description: 'Start with full foresight',
             configurable: true,
         },
+        {
+            type: ConfigType.SolvePath,
+            default: [],
+            field: 'solvePath',
+            description: 'Intended solve path',
+            configurable: true,
+        },
     ])
 });
 Object.defineProperty(ForesightRule, "SEARCH_VARIANTS", {

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

@@ -24,7 +24,7 @@ export default class MusicGridRule extends Rule implements GridChangeHandler, Se
     createExampleGrid(): GridData;
     get searchVariants(): SearchVariant[];
     validateGrid(_grid: GridData): RuleState;
-    onSetGrid(_oldGrid: GridData, newGrid: GridData): GridData;
+    onSetGrid(_oldGrid: GridData, newGrid: GridData, _solution: GridData | null): GridData;
     onGridChange(newGrid: GridData): this;
     onGridResize(_grid: GridData, mode: 'insert' | 'remove', direction: 'row' | 'column', index: number): this | null;
     /**

package/dist/data/rules/musicGridRule.js

@@ -56,7 +56,7 @@ class MusicGridRule extends Rule {
     validateGrid(_grid) {
         return { state: State.Incomplete };
     }
-    onSetGrid(_oldGrid, newGrid) {
+    onSetGrid(_oldGrid, newGrid, _solution) {
         if (newGrid.getTileCount(true, undefined, Color.Gray) === 0)
             return newGrid;
         const tiles = newGrid.tiles.map(row => row.map(tile => tile.color === Color.Gray ? tile.withColor(Color.Light) : tile));

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

@@ -0,0 +1,35 @@
+import { AnyConfig } from '../config.js';
+import GridData from '../grid.js';
+import { GridState, RuleState } from '../primitives.js';
+import Rule, { SearchVariant } from './rule.js';
+import { SetGridHandler } from '../events/onSetGrid.js';
+import { FinalValidationHandler } from '../events/onFinalValidation.js';
+export default class PerfectionRule extends Rule implements SetGridHandler, FinalValidationHandler {
+    private static readonly EXAMPLE_GRID;
+    private static readonly SEARCH_VARIANTS;
+    /**
+     * **Quest for Perfection: cell colors are final**
+     */
+    constructor();
+    get id(): string;
+    get explanation(): string;
+    get configs(): readonly AnyConfig[] | null;
+    createExampleGrid(): GridData;
+    get searchVariants(): SearchVariant[];
+    get necessaryForCompletion(): boolean;
+    get isSingleton(): boolean;
+    validateGrid(grid: GridData): RuleState;
+    /**
+     * If the grid passes validation but is different from the solution, indicate the error in the final state.
+     */
+    onFinalValidation(grid: GridData, solution: GridData | null, state: GridState): GridState;
+    private fixTiles;
+    /**
+     * Force all tiles to be fixed.
+     *
+     * If the grid is already wrong, prevent the player from changing it further.
+     */
+    onSetGrid(oldGrid: GridData, newGrid: GridData, solution: GridData | null): GridData;
+    copyWith(_: object): this;
+}
+export declare const instance: PerfectionRule;

package/dist/data/rules/perfectionRule.js

@@ -0,0 +1,113 @@
+import GridData from '../grid.js';
+import { Color, State } from '../primitives.js';
+import Rule from './rule.js';
+import CustomIconSymbol from '../symbols/customIconSymbol.js';
+class PerfectionRule extends Rule {
+    /**
+     * **Quest for Perfection: cell colors are final**
+     */
+    constructor() {
+        super();
+    }
+    get id() {
+        return `perfection`;
+    }
+    get explanation() {
+        return `*Quest for Perfection*: cell colors are final`;
+    }
+    get configs() {
+        return null;
+    }
+    createExampleGrid() {
+        return PerfectionRule.EXAMPLE_GRID;
+    }
+    get searchVariants() {
+        return PerfectionRule.SEARCH_VARIANTS;
+    }
+    get necessaryForCompletion() {
+        return false;
+    }
+    get isSingleton() {
+        return true;
+    }
+    validateGrid(grid) {
+        if (grid.getTileCount(true, undefined, Color.Gray) > 0) {
+            return { state: State.Incomplete };
+        }
+        else {
+            return { state: State.Satisfied };
+        }
+    }
+    /**
+     * If the grid passes validation but is different from the solution, indicate the error in the final state.
+     */
+    onFinalValidation(grid, solution, state) {
+        if (state.final === State.Error)
+            return state;
+        if (solution === null)
+            return state;
+        const positions = [];
+        grid.tiles.forEach((row, y) => row.forEach((t, x) => {
+            if (t.exists &&
+                t.color !== Color.Gray &&
+                t.color !== solution.getTile(x, y).color) {
+                positions.push({ x, y });
+            }
+        }));
+        if (positions.length > 0) {
+            const ruleId = grid.rules.indexOf(this);
+            return {
+                final: State.Error,
+                rules: state.rules.map((r, idx) => {
+                    if (idx === ruleId) {
+                        return { state: State.Error, positions };
+                    }
+                    else {
+                        return r;
+                    }
+                }),
+                symbols: state.symbols,
+            };
+        }
+        return state;
+    }
+    fixTiles(grid) {
+        if (grid.getTileCount(true, false, Color.Light) > 0 ||
+            grid.getTileCount(true, false, Color.Dark) > 0) {
+            return grid.withTiles(tiles => tiles.map(row => row.map(t => t.exists && t.color !== Color.Gray ? t.withFixed(true) : t)));
+        }
+        return grid;
+    }
+    /**
+     * Force all tiles to be fixed.
+     *
+     * If the grid is already wrong, prevent the player from changing it further.
+     */
+    onSetGrid(oldGrid, newGrid, solution) {
+        if (!solution) {
+            return this.fixTiles(newGrid);
+        }
+        if (!oldGrid.solutionMatches(solution) &&
+            !newGrid.solutionMatches(solution)) {
+            return this.fixTiles(oldGrid);
+        }
+        return this.fixTiles(newGrid);
+    }
+    copyWith(_) {
+        return new PerfectionRule();
+    }
+}
+Object.defineProperty(PerfectionRule, "EXAMPLE_GRID", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: Object.freeze(GridData.create(['w']).addSymbol(new CustomIconSymbol('', GridData.create(['w']), 0, 0, 'MdStars')))
+});
+Object.defineProperty(PerfectionRule, "SEARCH_VARIANTS", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: []
+}); // this rule is not searchable
+export default PerfectionRule;
+export const instance = new PerfectionRule();

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

@@ -7,6 +7,7 @@ export { instance as ForesightRule } from './foresightRule.js';
 export { instance as MusicGridRule } from './musicGridRule.js';
 export { instance as MysteryRule } from './mysteryRule.js';
 export { instance as OffByXRule } from './offByXRule.js';
+export { instance as PerfectionRule } from './perfectionRule.js';
 export { instance as RegionAreaRule } from './regionAreaRule.js';
 export { instance as SameShapeRule } from './sameShapeRule.js';
 export { instance as SymbolsPerRegionRule } from './symbolsPerRegionRule.js';

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

@@ -11,6 +11,7 @@ export { instance as ForesightRule } from './foresightRule.js';
 export { instance as MusicGridRule } from './musicGridRule.js';
 export { instance as MysteryRule } from './mysteryRule.js';
 export { instance as OffByXRule } from './offByXRule.js';
+export { instance as PerfectionRule } from './perfectionRule.js';
 export { instance as RegionAreaRule } from './regionAreaRule.js';
 export { instance as SameShapeRule } from './sameShapeRule.js';
 export { instance as SymbolsPerRegionRule } from './symbolsPerRegionRule.js';

package/dist/data/serializer/serializer_v0.js

@@ -161,6 +161,12 @@ export default class SerializerV0 extends SerializerBase {
                     escape(instruction[config.field]
                         .map(line => this.stringifyControlLine(line))
                         .join(':')));
+            case ConfigType.SolvePath:
+                return (config.field +
+                    '=' +
+                    escape(instruction[config.field]
+                        ?.map(pos => `${pos.x}_${pos.y}`)
+                        .join('/') ?? ''));
         }
     }
     parseConfig(configs, entry) {
@@ -219,6 +225,16 @@ export default class SerializerV0 extends SerializerBase {
                 ];
             case ConfigType.NullableNote:
                 return [config.field, value === '' ? null : unescape(value)];
+            case ConfigType.SolvePath:
+                return [
+                    config.field,
+                    value === ''
+                        ? []
+                        : value.split('/').map(pos => {
+                            const [x, y] = pos.split('_');
+                            return { x: Number(x), y: Number(y) };
+                        }),
+                ];
         }
     }
     stringifyInstruction(instruction) {

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

@@ -50,7 +50,7 @@ class BacktrackSolver extends Solver {
                 });
                 worker.addEventListener('error', (e) => {
                     alert(`Error while solving!\n${e.message}`);
-                    fail(new Error(e.message));
+                    fail(e);
                 });
             });
             for await (const solution of iterator) {

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

@@ -4,6 +4,8 @@ import BTModule, { BTGridData, CheckResult } from '../data.js';
 export default abstract class DirectionLinkerBTModule extends BTModule {
     instr: DirectionLinkerSymbol;
     constructor(instr: DirectionLinkerSymbol);
+    private initialPositions;
+    private getInitialPositions;
     checkGlobal(grid: BTGridData): CheckResult | false;
     protected abstract movePos(grid: BTGridData, x: number, y: number): Position | null;
 }

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

@@ -1,4 +1,4 @@
-import BTModule, { BTTile, IntArray2D, createOneTileResult, } from '../data.js';
+import BTModule, { BTTile, IntArray2D, } from '../data.js';
 export default class DirectionLinkerBTModule extends BTModule {
     constructor(instr) {
         super();
@@ -8,31 +8,108 @@ export default class DirectionLinkerBTModule extends BTModule {
             writable: true,
             value: void 0
         });
+        Object.defineProperty(this, "initialPositions", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
         this.instr = instr;
     }
+    getInitialPositions() {
+        if (this.instr.x % 1 !== 0 && this.instr.y % 1 !== 0)
+            return [
+                { x: Math.floor(this.instr.x), y: Math.floor(this.instr.y) },
+                { x: Math.ceil(this.instr.x), y: Math.ceil(this.instr.y) },
+                { x: Math.floor(this.instr.x), y: Math.ceil(this.instr.y) },
+                { x: Math.ceil(this.instr.x), y: Math.floor(this.instr.y) },
+            ];
+        else if (this.instr.x % 1 !== 0)
+            return [
+                { x: Math.floor(this.instr.x), y: this.instr.y },
+                { x: Math.ceil(this.instr.x), y: this.instr.y },
+            ];
+        else if (this.instr.y % 1 !== 0)
+            return [
+                { x: this.instr.x, y: Math.floor(this.instr.y) },
+                { x: this.instr.x, y: Math.ceil(this.instr.y) },
+            ];
+        else
+            return [{ x: this.instr.x, y: this.instr.y }];
+    }
     checkGlobal(grid) {
-        const thisX = Math.floor(this.instr.x);
-        const thisY = Math.floor(this.instr.y);
-        const tile = grid.getTile(thisX, thisY);
-        if (tile === BTTile.Empty)
-            return createOneTileResult(grid, { x: thisX, y: thisY });
+        if (this.initialPositions === null)
+            this.initialPositions = this.getInitialPositions();
         const tilesNeedCheck = IntArray2D.create(grid.width, grid.height);
         const ratings = [];
-        const queue = [{ x: thisX, y: thisY }];
+        let checkable = false;
+        for (const pos of this.initialPositions) {
+            const tile = grid.isInBound(pos.x, pos.y)
+                ? grid.getTile(pos.x, pos.y)
+                : BTTile.NonExist;
+            if (tile === BTTile.Empty) {
+                const oppoPos = this.movePos(grid, pos.x, pos.y);
+                if (oppoPos === null ||
+                    grid.getTile(oppoPos.x, oppoPos.y) === BTTile.NonExist)
+                    return false;
+                else {
+                    tilesNeedCheck.set(pos.x, pos.y, 1);
+                    ratings.push({ pos, score: 1 });
+                }
+            }
+            else if (tile === BTTile.NonExist) {
+                const oppoPos = this.movePos(grid, pos.x, pos.y);
+                if (oppoPos !== null &&
+                    grid.getTile(oppoPos.x, oppoPos.y) !== BTTile.NonExist) {
+                    return false;
+                }
+            }
+            else {
+                const oppoPos = this.movePos(grid, pos.x, pos.y);
+                if (oppoPos !== null) {
+                    const oppoTile = grid.getTile(oppoPos.x, oppoPos.y);
+                    if (oppoTile === BTTile.Empty) {
+                        tilesNeedCheck.set(pos.x, pos.y, 1);
+                        ratings.push({ pos, score: 1 });
+                    }
+                    else if (oppoTile === BTTile.NonExist)
+                        return false;
+                    else
+                        checkable = true;
+                }
+                else {
+                    return false;
+                }
+            }
+        }
+        if (!checkable) {
+            return { tilesNeedCheck, ratings };
+        }
+        const queue = this.initialPositions
+            .filter(pos => grid.isInBound(pos.x, pos.y) &&
+            grid.getTile(pos.x, pos.y) !== BTTile.NonExist)
+            .map(pos => {
+            const oppoPos = this.movePos(grid, pos.x, pos.y);
+            return {
+                pos,
+                color: grid.getTile(pos.x, pos.y),
+                oppoColor: grid.getTile(oppoPos.x, oppoPos.y),
+            };
+        });
         const visited = IntArray2D.create(grid.width, grid.height);
         // Visit all connected tiles
         while (queue.length > 0) {
             const curPos = queue.pop();
-            if (visited.get(curPos.x, curPos.y))
+            if (visited.get(curPos.pos.x, curPos.pos.y))
                 continue;
-            visited.set(curPos.x, curPos.y, 1);
-            const oppoPos = this.movePos(grid, curPos.x, curPos.y);
+            visited.set(curPos.pos.x, curPos.pos.y, 1);
+            const oppoPos = this.movePos(grid, curPos.pos.x, curPos.pos.y);
             if (oppoPos === null)
                 return false;
             const oppoTile = grid.getTile(oppoPos.x, oppoPos.y);
-            if (!(oppoTile === BTTile.Empty || oppoTile === tile))
+            if (!(oppoTile === BTTile.Empty || oppoTile === curPos.oppoColor))
                 return false;
-            for (const edge of grid.getEdges(curPos)) {
+            for (const edge of grid.getEdges(curPos.pos)) {
                 if (visited.get(edge.x, edge.y))
                     continue;
                 const edgeTile = grid.getTile(edge.x, edge.y);
@@ -40,8 +117,12 @@ export default class DirectionLinkerBTModule extends BTModule {
                     tilesNeedCheck.set(edge.x, edge.y, 1);
                     ratings.push({ pos: edge, score: 1 });
                 }
-                else if (edgeTile === tile) {
-                    queue.push(edge);
+                else if (edgeTile === curPos.color) {
+                    queue.push({
+                        pos: edge,
+                        color: curPos.color,
+                        oppoColor: curPos.oppoColor,
+                    });
                 }
             }
         }

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

@@ -1,9 +1,11 @@
 import { Position } from '../../../primitives.js';
 import LotusSymbol from '../../../symbols/lotusSymbol.js';
-import { BTGridData } from '../data.js';
+import { BTGridData, CheckResult } from '../data.js';
 import DirectionLinkerBTModule from './directionLinker.js';
 export default class LotusBTModule extends DirectionLinkerBTModule {
     instr: LotusSymbol;
     constructor(instr: LotusSymbol);
     protected movePos(grid: BTGridData, x: number, y: number): Position | null;
+    private getTileSafe;
+    checkGlobal(grid: BTGridData): false | CheckResult;
 }

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

@@ -1,4 +1,5 @@
 import { Orientation } from '../../../primitives.js';
+import { BTTile } from '../data.js';
 import DirectionLinkerBTModule from './directionLinker.js';
 export default class LotusBTModule extends DirectionLinkerBTModule {
     constructor(instr) {
@@ -33,4 +34,27 @@ export default class LotusBTModule extends DirectionLinkerBTModule {
         }
         return grid.isInBound(pos.x, pos.y) ? pos : null;
     }
+    getTileSafe(grid, x, y) {
+        return grid.isInBound(x, y) ? grid.getTile(x, y) : BTTile.NonExist;
+    }
+    checkGlobal(grid) {
+        if (this.instr.orientation === Orientation.DownLeft ||
+            this.instr.orientation === Orientation.DownRight ||
+            this.instr.orientation === Orientation.UpLeft ||
+            this.instr.orientation === Orientation.UpRight) {
+            if (this.instr.x % 1 === 0 || this.instr.y % 1 === 0)
+                if (this.instr.x % 1 !== 0 || this.instr.y % 1 !== 0) {
+                    if (this.getTileSafe(grid, Math.floor(this.instr.x), Math.floor(this.instr.y)) === BTTile.NonExist &&
+                        this.getTileSafe(grid, Math.ceil(this.instr.x), Math.ceil(this.instr.y)) === BTTile.NonExist &&
+                        this.getTileSafe(grid, Math.floor(this.instr.x), Math.ceil(this.instr.y)) === BTTile.NonExist &&
+                        this.getTileSafe(grid, Math.ceil(this.instr.x), Math.floor(this.instr.y)) === BTTile.NonExist) {
+                        return { tilesNeedCheck: null, ratings: null };
+                    }
+                    else {
+                        return false;
+                    }
+                }
+        }
+        return super.checkGlobal(grid);
+    }
 }

package/dist/data/symbols/directionLinkerSymbol.d.ts

@@ -24,7 +24,6 @@ export default class DirectionLinkerSymbol extends Symbol {
     get explanation(): string;
     get configs(): readonly AnyConfig[] | null;
     createExampleGrid(): GridData;
-    private getColor;
     private deltaCoordinate;
     validateSymbol(grid: GridData): State;
     copyWith({ x, y }: {

package/dist/data/symbols/directionLinkerSymbol.js

@@ -2,6 +2,20 @@ import { ConfigType } from '../config.js';
 import GridData from '../grid.js';
 import { Color, Direction, State } from '../primitives.js';
 import Symbol from './symbol.js';
+function getColor(c, grid) {
+    if (!grid.isPositionValid(c.x, c.y) || !grid.getTile(c.x, c.y).exists) {
+        return null;
+    }
+    return grid.getTile(c.x, c.y).color;
+}
+function makeTurtle(pos1, pos2, grid) {
+    return {
+        pos1,
+        color1: getColor(pos1, grid),
+        pos2,
+        color2: getColor(pos2, grid),
+    };
+}
 class DirectionLinkerSymbol extends Symbol {
     /**
      * **Darts count opposite color cells in that direction**
@@ -51,12 +65,6 @@ class DirectionLinkerSymbol extends Symbol {
     createExampleGrid() {
         return DirectionLinkerSymbol.EXAMPLE_GRID;
     }
-    getColor(c, grid) {
-        if (!grid.isPositionValid(c.x, c.y) || !grid.getTile(c.x, c.y).exists) {
-            return null;
-        }
-        return grid.getTile(c.x, c.y).color;
-    }
     deltaCoordinate(c, direction) {
         return {
             x: c.x + DirectionLinkerSymbol.directionDeltas[direction].dx,
@@ -73,49 +81,56 @@ class DirectionLinkerSymbol extends Symbol {
         // If the color of both are the opposite of the turtle, the turtle doesn't fire any other turtle
         // If no turtle remains, go to final state
         // Final state is State.Satisfied if no gray cell is found, State.Incomplete otherwise
-        const baseColor = grid.getTile(Math.round(this.x), Math.round(this.y)).color;
-        if (baseColor === Color.Gray) {
+        let checkedCouples = this.getInitialCheckedCouples(this.x, this.y, grid);
+        if (checkedCouples.some(({ color1, color2 }) => (color1 === null && color2 !== null) ||
+            (color1 !== null && color2 === null))) {
+            return State.Error;
+        }
+        if (checkedCouples.some(({ color1, color2 }) => color1 === Color.Gray || color2 === Color.Gray)) {
             return State.Incomplete;
         }
-        const checkedCouples = this.getInitialCheckedCouples(this.x, this.y);
-        const queue = checkedCouples.map(([p1, p2]) => [
-            { ...p1 },
-            { ...p2 },
-        ]);
+        checkedCouples = checkedCouples.filter(({ color1, color2 }) => color1 !== null && color2 !== null);
+        const queue = checkedCouples.slice();
         let grayFound = false;
         while (queue.length > 0) {
             const turtle = queue.shift();
-            const [c1, c2] = turtle;
-            const color1 = this.getColor(c1, grid);
-            const color2 = this.getColor(c2, grid);
-            const colorSet = new Set([color1, color2]);
-            if (colorSet.has(null) && !colorSet.has(baseColor)) {
-                colorSet.delete(null);
+            const { pos1, pos2, color1: baseColor1, color2: baseColor2 } = turtle;
+            const color1 = getColor(pos1, grid);
+            const color2 = getColor(pos2, grid);
+            if (color1 === Color.Gray || color2 === Color.Gray) {
+                grayFound = true;
             }
-            if (colorSet.size === 2 && !colorSet.has(Color.Gray)) {
-                return State.Error;
+            else if (color1 === null || color2 === null) {
+                if ((color1 === null && color2 === baseColor2) ||
+                    (color2 === null && color1 === baseColor1)) {
+                    return State.Error;
+                }
             }
-            if (colorSet.has(Color.Gray)) {
-                grayFound = true;
+            else if (color1 !== baseColor1 || color2 !== baseColor2) {
+                if (color1 === baseColor1 || color2 === baseColor2) {
+                    return State.Error;
+                }
             }
-            if (color1 === baseColor) {
+            if (color1 === baseColor1) {
                 const directions = Object.keys(this.linkedDirections);
                 for (const direction of directions) {
-                    const newTurtle = [
-                        this.deltaCoordinate(c1, direction),
-                        this.deltaCoordinate(c2, this.linkedDirections[direction]),
-                    ];
-                    if (checkedCouples.some(([c1, c2]) => c1.x === newTurtle[0].x &&
-                        c1.y === newTurtle[0].y &&
-                        c2.x === newTurtle[1].x &&
-                        c2.y === newTurtle[1].y) ||
-                        (c1.x === newTurtle[1].x &&
-                            c1.y === newTurtle[1].y &&
-                            c2.x === newTurtle[0].x &&
-                            c2.y === newTurtle[0].y)) {
+                    const newTurtle = {
+                        pos1: this.deltaCoordinate(pos1, direction),
+                        pos2: this.deltaCoordinate(pos2, this.linkedDirections[direction]),
+                        color1: baseColor1,
+                        color2: baseColor2,
+                    };
+                    if (checkedCouples.some(({ pos1, pos2 }) => pos1.x === newTurtle.pos1.x &&
+                        pos1.y === newTurtle.pos1.y &&
+                        pos2.x === newTurtle.pos2.x &&
+                        pos2.y === newTurtle.pos2.y) ||
+                        (pos1.x === newTurtle.pos2.x &&
+                            pos1.y === newTurtle.pos2.y &&
+                            pos2.x === newTurtle.pos1.x &&
+                            pos2.y === newTurtle.pos1.y)) {
                         continue;
                     }
-                    checkedCouples.push([newTurtle[0], newTurtle[1]]);
+                    checkedCouples.push(newTurtle);
                     queue.push(newTurtle);
                 }
             }
@@ -125,73 +140,50 @@ class DirectionLinkerSymbol extends Symbol {
     copyWith({ x, y }) {
         return new DirectionLinkerSymbol(x ?? this.x, y ?? this.y);
     }
-    getInitialCheckedCouples(x, y) {
+    getInitialCheckedCouples(x, y, grid) {
         // 1x1
         if (x % 1 === 0 && y % 1 === 0) {
-            return [
-                [
-                    { x, y },
-                    { x, y },
-                ],
-            ];
+            return [makeTurtle({ x, y }, { x, y }, grid)];
         }
         // 1x2
         if (x % 1 === 0) {
             return [
-                [
-                    { x, y: y - 0.5 },
-                    {
-                        x,
-                        y: y +
-                            (this.linkedDirections[Direction.Up] === Direction.Up &&
-                                this.linkedDirections[Direction.Down] === Direction.Down
-                                ? -0.5
-                                : 0.5),
-                    },
-                ],
+                makeTurtle({ x, y: y - 0.5 }, {
+                    x,
+                    y: y +
+                        (this.linkedDirections[Direction.Up] === Direction.Up &&
+                            this.linkedDirections[Direction.Down] === Direction.Down
+                            ? -0.5
+                            : 0.5),
+                }, grid),
             ];
         }
         // 2x1
         if (y % 1 === 0) {
             return [
-                [
-                    { x: x - 0.5, y },
-                    {
-                        x: x +
-                            (this.linkedDirections[Direction.Left] === Direction.Left &&
-                                this.linkedDirections[Direction.Right] === Direction.Right
-                                ? -0.5
-                                : 0.5),
-                        y,
-                    },
-                ],
+                makeTurtle({ x: x - 0.5, y }, {
+                    x: x +
+                        (this.linkedDirections[Direction.Left] === Direction.Left &&
+                            this.linkedDirections[Direction.Right] === Direction.Right
+                            ? -0.5
+                            : 0.5),
+                    y,
+                }, grid),
             ];
         }
         // 2x2
         if (this.linkedDirections[Direction.Left] === Direction.Left &&
             this.linkedDirections[Direction.Right] === Direction.Right) {
             return [
-                [
-                    { x: x - 0.5, y: y - 0.5 },
-                    { x: x - 0.5, y: y + 0.5 },
-                ],
-                [
-                    { x: x + 0.5, y: y - 0.5 },
-                    { x: x + 0.5, y: y + 0.5 },
-                ],
+                makeTurtle({ x: x - 0.5, y: y - 0.5 }, { x: x - 0.5, y: y + 0.5 }, grid),
+                makeTurtle({ x: x + 0.5, y: y - 0.5 }, { x: x + 0.5, y: y + 0.5 }, grid),
             ];
         }
         if (this.linkedDirections[Direction.Up] === Direction.Up &&
             this.linkedDirections[Direction.Down] === Direction.Down) {
             return [
-                [
-                    { x: x - 0.5, y: y - 0.5 },
-                    { x: x + 0.5, y: y - 0.5 },
-                ],
-                [
-                    { x: x - 0.5, y: y + 0.5 },
-                    { x: x + 0.5, y: y + 0.5 },
-                ],
+                makeTurtle({ x: x - 0.5, y: y - 0.5 }, { x: x + 0.5, y: y - 0.5 }, grid),
+                makeTurtle({ x: x - 0.5, y: y + 0.5 }, { x: x + 0.5, y: y + 0.5 }, grid),
             ];
         }
         else if ((this.linkedDirections[Direction.Up] === Direction.Left &&
@@ -199,21 +191,12 @@ class DirectionLinkerSymbol extends Symbol {
             (this.linkedDirections[Direction.Up] === Direction.Right &&
                 this.linkedDirections[Direction.Right] === Direction.Up)) {
             return [
-                [
-                    { x: x - 0.5, y: y - 0.5 },
-                    { x: x - 0.5, y: y - 0.5 },
-                ],
+                makeTurtle({ x: x - 0.5, y: y - 0.5 }, { x: x - 0.5, y: y - 0.5 }, grid),
             ];
         }
         return [
-            [
-                { x: x - 0.5, y: y - 0.5 },
-                { x: x + 0.5, y: y + 0.5 },
-            ],
-            [
-                { x: x - 0.5, y: y + 0.5 },
-                { x: x + 0.5, y: y - 0.5 },
-            ],
+            makeTurtle({ x: x - 0.5, y: y - 0.5 }, { x: x + 0.5, y: y + 0.5 }, grid),
+            makeTurtle({ x: x - 0.5, y: y + 0.5 }, { x: x + 0.5, y: y - 0.5 }, grid),
         ];
     }
 }

package/dist/data/symbols/lotusSymbol.js

@@ -1,6 +1,6 @@
 import { ConfigType } from '../config.js';
 import GridData from '../grid.js';
-import { Direction, Orientation } from '../primitives.js';
+import { Direction, Orientation, State } from '../primitives.js';
 import DirectionLinkerSymbol from './directionLinkerSymbol.js';
 class LotusSymbol extends DirectionLinkerSymbol {
     /**
@@ -67,6 +67,23 @@ class LotusSymbol extends DirectionLinkerSymbol {
         return Object.freeze(GridData.create(['wwbww', 'bwbwb', 'bwwwb', 'bwwwb']).addSymbol(new LotusSymbol(2, 2, Orientation.Up)));
     }
     validateSymbol(grid) {
+        if (this.orientation === Orientation.DownLeft ||
+            this.orientation === Orientation.DownRight ||
+            this.orientation === Orientation.UpLeft ||
+            this.orientation === Orientation.UpRight) {
+            if (this.x % 1 === 0 || this.y % 1 === 0)
+                if (this.x % 1 !== 0 || this.y % 1 !== 0) {
+                    if (!grid.getTile(Math.floor(this.x), Math.floor(this.y)).exists &&
+                        !grid.getTile(Math.ceil(this.x), Math.ceil(this.y)).exists &&
+                        !grid.getTile(Math.floor(this.x), Math.ceil(this.y)).exists &&
+                        !grid.getTile(Math.ceil(this.x), Math.floor(this.y)).exists) {
+                        return State.Satisfied;
+                    }
+                    else {
+                        return State.Error;
+                    }
+                }
+        }
         return super.validateSymbol(grid);
     }
     copyWith({ x, y, orientation, }) {

package/dist/index.d.ts

@@ -24,6 +24,7 @@ import { ControlLine, Row } from './data/rules/musicControlLine.js';
 import MusicGridRule from './data/rules/musicGridRule.js';
 import MysteryRule from './data/rules/mysteryRule.js';
 import OffByXRule from './data/rules/offByXRule.js';
+import PerfectionRule from './data/rules/perfectionRule.js';
 import RegionAreaRule from './data/rules/regionAreaRule.js';
 import RegionShapeRule from './data/rules/regionShapeRule.js';
 import Rule from './data/rules/rule.js';
@@ -95,4 +96,4 @@ import ViewpointSymbol from './data/symbols/viewpointSymbol.js';
 import TileData from './data/tile.js';
 import TileConnections from './data/tileConnections.js';
 import validateGrid, { aggregateState, applyFinalOverrides } from './data/validate.js';
-export { ConfigType, configEquals, Configurable, CachedAccess, allEqual, array, directionToRotation, escape, maxBy, minBy, move, orientationToRotation, resize, unescape, isEventHandler, handlesFinalValidation, handlesGridChange, handlesGridResize, handlesSetGrid, handlesSymbolDisplay, handlesSymbolValidation, GridData, GridConnections, Instruction, COMPARISONS, Color, Comparison, DIRECTIONS, Direction, MajorRule, Mode, ORIENTATIONS, Orientation, State, directionToggle, orientationToggle, MetadataSchema, PuzzleSchema, BanPatternRule, CellCountRule, CompletePatternRule, ConnectAllRule, CustomRule, ForesightRule, allRules, ControlLine, Row, MusicGridRule, MysteryRule, OffByXRule, RegionAreaRule, RegionShapeRule, Rule, SameShapeRule, SymbolsPerRegionRule, UndercluedRule, UniqueShapeRule, Serializer, Compressor, CompressorBase, DeflateCompressor, GzipCompressor, StreamCompressor, SerializerBase, SerializerV0, getShapeVariants, normalizeShape, positionsToShape, shapeEquals, tilesToShape, allSolvers, BacktrackSolver, BTModule, BTGridData, BTTile, IntArray2D, colorToBTTile, createOneTileResult, getOppositeColor, BanPatternBTModule, CellCountBTModule, ConnectAllBTModule, RegionAreaBTModule, RegionShapeBTModule, SameShapeBTModule, SymbolsPerRegionBTModule, UniqueShapeBTModule, AreaNumberBTModule, DartBTModule, DirectionLinkerBTModule, GalaxyBTModule, LetterBTModule, LotusBTModule, MinesweeperBTModule, MyopiaBTModule, ViewpointBTModule, Solver, UndercluedSolver, AreaNumberModule, CellCountModule, ConnectAllModule, DartModule, allZ3Modules, LetterModule, MyopiaModule, RegionAreaModule, ViewpointModule, Z3Module, convertDirection, Z3Solver, Z3SolverContext, AreaNumberSymbol, CustomIconSymbol, CustomSymbol, CustomTextSymbol, DartSymbol, DirectionLinkerSymbol, GalaxySymbol, HiddenSymbol, allSymbols, LetterSymbol, LotusSymbol, MinesweeperSymbol, MultiEntrySymbol, MyopiaSymbol, NumberSymbol, Symbol, ViewpointSymbol, TileData, TileConnections, validateGrid, aggregateState, applyFinalOverrides, };
+export { ConfigType, configEquals, Configurable, CachedAccess, allEqual, array, directionToRotation, escape, maxBy, minBy, move, orientationToRotation, resize, unescape, isEventHandler, handlesFinalValidation, handlesGridChange, handlesGridResize, handlesSetGrid, handlesSymbolDisplay, handlesSymbolValidation, GridData, GridConnections, Instruction, COMPARISONS, Color, Comparison, DIRECTIONS, Direction, MajorRule, Mode, ORIENTATIONS, Orientation, State, directionToggle, orientationToggle, MetadataSchema, PuzzleSchema, BanPatternRule, CellCountRule, CompletePatternRule, ConnectAllRule, CustomRule, ForesightRule, allRules, ControlLine, Row, MusicGridRule, MysteryRule, OffByXRule, PerfectionRule, RegionAreaRule, RegionShapeRule, Rule, SameShapeRule, SymbolsPerRegionRule, UndercluedRule, UniqueShapeRule, Serializer, Compressor, CompressorBase, DeflateCompressor, GzipCompressor, StreamCompressor, SerializerBase, SerializerV0, getShapeVariants, normalizeShape, positionsToShape, shapeEquals, tilesToShape, allSolvers, BacktrackSolver, BTModule, BTGridData, BTTile, IntArray2D, colorToBTTile, createOneTileResult, getOppositeColor, BanPatternBTModule, CellCountBTModule, ConnectAllBTModule, RegionAreaBTModule, RegionShapeBTModule, SameShapeBTModule, SymbolsPerRegionBTModule, UniqueShapeBTModule, AreaNumberBTModule, DartBTModule, DirectionLinkerBTModule, GalaxyBTModule, LetterBTModule, LotusBTModule, MinesweeperBTModule, MyopiaBTModule, ViewpointBTModule, Solver, UndercluedSolver, AreaNumberModule, CellCountModule, ConnectAllModule, DartModule, allZ3Modules, LetterModule, MyopiaModule, RegionAreaModule, ViewpointModule, Z3Module, convertDirection, Z3Solver, Z3SolverContext, AreaNumberSymbol, CustomIconSymbol, CustomSymbol, CustomTextSymbol, DartSymbol, DirectionLinkerSymbol, GalaxySymbol, HiddenSymbol, allSymbols, LetterSymbol, LotusSymbol, MinesweeperSymbol, MultiEntrySymbol, MyopiaSymbol, NumberSymbol, Symbol, ViewpointSymbol, TileData, TileConnections, validateGrid, aggregateState, applyFinalOverrides, };

package/dist/index.js

@@ -27,6 +27,7 @@ import { ControlLine, Row } from './data/rules/musicControlLine.js';
 import MusicGridRule from './data/rules/musicGridRule.js';
 import MysteryRule from './data/rules/mysteryRule.js';
 import OffByXRule from './data/rules/offByXRule.js';
+import PerfectionRule from './data/rules/perfectionRule.js';
 import RegionAreaRule from './data/rules/regionAreaRule.js';
 import RegionShapeRule from './data/rules/regionShapeRule.js';
 import Rule from './data/rules/rule.js';
@@ -98,4 +99,4 @@ import ViewpointSymbol from './data/symbols/viewpointSymbol.js';
 import TileData from './data/tile.js';
 import TileConnections from './data/tileConnections.js';
 import validateGrid, { aggregateState, applyFinalOverrides } from './data/validate.js';
-export { ConfigType, configEquals, Configurable, CachedAccess, allEqual, array, directionToRotation, escape, maxBy, minBy, move, orientationToRotation, resize, unescape, isEventHandler, handlesFinalValidation, handlesGridChange, handlesGridResize, handlesSetGrid, handlesSymbolDisplay, handlesSymbolValidation, GridData, GridConnections, Instruction, COMPARISONS, Color, Comparison, DIRECTIONS, Direction, MajorRule, Mode, ORIENTATIONS, Orientation, State, directionToggle, orientationToggle, MetadataSchema, PuzzleSchema, BanPatternRule, CellCountRule, CompletePatternRule, ConnectAllRule, CustomRule, ForesightRule, allRules, ControlLine, Row, MusicGridRule, MysteryRule, OffByXRule, RegionAreaRule, RegionShapeRule, Rule, SameShapeRule, SymbolsPerRegionRule, UndercluedRule, UniqueShapeRule, Serializer, Compressor, CompressorBase, DeflateCompressor, GzipCompressor, StreamCompressor, SerializerBase, SerializerV0, getShapeVariants, normalizeShape, positionsToShape, shapeEquals, tilesToShape, allSolvers, BacktrackSolver, BTModule, BTGridData, BTTile, IntArray2D, colorToBTTile, createOneTileResult, getOppositeColor, BanPatternBTModule, CellCountBTModule, ConnectAllBTModule, RegionAreaBTModule, RegionShapeBTModule, SameShapeBTModule, SymbolsPerRegionBTModule, UniqueShapeBTModule, AreaNumberBTModule, DartBTModule, DirectionLinkerBTModule, GalaxyBTModule, LetterBTModule, LotusBTModule, MinesweeperBTModule, MyopiaBTModule, ViewpointBTModule, Solver, UndercluedSolver, AreaNumberModule, CellCountModule, ConnectAllModule, DartModule, allZ3Modules, LetterModule, MyopiaModule, RegionAreaModule, ViewpointModule, Z3Module, convertDirection, Z3Solver, Z3SolverContext, AreaNumberSymbol, CustomIconSymbol, CustomSymbol, CustomTextSymbol, DartSymbol, DirectionLinkerSymbol, GalaxySymbol, HiddenSymbol, allSymbols, LetterSymbol, LotusSymbol, MinesweeperSymbol, MultiEntrySymbol, MyopiaSymbol, NumberSymbol, Symbol, ViewpointSymbol, TileData, TileConnections, validateGrid, aggregateState, applyFinalOverrides, };
+export { ConfigType, configEquals, Configurable, CachedAccess, allEqual, array, directionToRotation, escape, maxBy, minBy, move, orientationToRotation, resize, unescape, isEventHandler, handlesFinalValidation, handlesGridChange, handlesGridResize, handlesSetGrid, handlesSymbolDisplay, handlesSymbolValidation, GridData, GridConnections, Instruction, COMPARISONS, Color, Comparison, DIRECTIONS, Direction, MajorRule, Mode, ORIENTATIONS, Orientation, State, directionToggle, orientationToggle, MetadataSchema, PuzzleSchema, BanPatternRule, CellCountRule, CompletePatternRule, ConnectAllRule, CustomRule, ForesightRule, allRules, ControlLine, Row, MusicGridRule, MysteryRule, OffByXRule, PerfectionRule, RegionAreaRule, RegionShapeRule, Rule, SameShapeRule, SymbolsPerRegionRule, UndercluedRule, UniqueShapeRule, Serializer, Compressor, CompressorBase, DeflateCompressor, GzipCompressor, StreamCompressor, SerializerBase, SerializerV0, getShapeVariants, normalizeShape, positionsToShape, shapeEquals, tilesToShape, allSolvers, BacktrackSolver, BTModule, BTGridData, BTTile, IntArray2D, colorToBTTile, createOneTileResult, getOppositeColor, BanPatternBTModule, CellCountBTModule, ConnectAllBTModule, RegionAreaBTModule, RegionShapeBTModule, SameShapeBTModule, SymbolsPerRegionBTModule, UniqueShapeBTModule, AreaNumberBTModule, DartBTModule, DirectionLinkerBTModule, GalaxyBTModule, LetterBTModule, LotusBTModule, MinesweeperBTModule, MyopiaBTModule, ViewpointBTModule, Solver, UndercluedSolver, AreaNumberModule, CellCountModule, ConnectAllModule, DartModule, allZ3Modules, LetterModule, MyopiaModule, RegionAreaModule, ViewpointModule, Z3Module, convertDirection, Z3Solver, Z3SolverContext, AreaNumberSymbol, CustomIconSymbol, CustomSymbol, CustomTextSymbol, DartSymbol, DirectionLinkerSymbol, GalaxySymbol, HiddenSymbol, allSymbols, LetterSymbol, LotusSymbol, MinesweeperSymbol, MultiEntrySymbol, MyopiaSymbol, NumberSymbol, Symbol, ViewpointSymbol, TileData, TileConnections, validateGrid, aggregateState, applyFinalOverrides, };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@logic-pad/core",
-  "version": "0.2.1",
+  "version": "0.3.0",
   "type": "module",
   "files": [
     "dist",