@logic-pad/core 0.9.0 → 0.10.1

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

@@ -9,6 +9,7 @@ declare global {
   // Generated by dts-bundle-generator v9.5.1
 
   import { RegionConstrainer, SymbolGrid } from 'grilops';
+  import { PuzzleData } from 'logic-pad-solver-core';
   import { Optimize, Solver as Solver$1, Z3LowLevel } from 'z3-solver';
   import { z } from 'zod';
 
@@ -2120,7 +2121,7 @@ declare global {
     readonly id = 'backtrack';
     readonly author = 'ALaggyDev';
     readonly description =
-      'Solves puzzles using backtracking with optimizations (blazingly fast). Support most rules and symbols (including underclued).';
+      'Solves puzzles pretty fast using backtracking with optimizations. Support most rules and symbols (including underclued).';
     protected createWorker(): Worker;
     isInstructionSupported(instructionId: string): boolean;
   }
@@ -2629,6 +2630,18 @@ declare global {
     constructor(instr: ViewpointSymbol);
     checkGlobal(grid: BTGridData): CheckResult | false;
   }
+  export declare class CspuzSolver extends EventIteratingSolver {
+    private static readonly supportedInstrs;
+    readonly id = 'cspuz';
+    readonly author = 'semiexp';
+    readonly description =
+      'A blazingly fast WebAssembly solver that supports most rules and symbols (including underclued). No uniqueness check yet.';
+    protected createWorker(): Worker;
+    isGridSupported(grid: GridData): boolean;
+    isInstructionSupported(instructionId: string): boolean;
+    isEnvironmentSupported(): Promise<boolean>;
+  }
+  export declare function gridToJson(grid: GridData): PuzzleData;
   export declare class UniversalSolver extends EventIteratingSolver {
     readonly id = 'universal';
     readonly author = 'romain22222, Lysine';
@@ -2724,7 +2737,7 @@ declare global {
     readonly id = 'z3';
     readonly author = 'Lysine';
     readonly description =
-      'Good for confirming that a solution is unique, especially for larger puzzles. It is otherwise slower than most solvers in small to medium-sized puzzles.';
+      '(Obsolete) A WebAssembly solver that supports a limited set of rules and symbols.';
     readonly supportsCancellation = false;
     isEnvironmentSupported(): Promise<boolean>;
     solve(grid: GridData): AsyncGenerator<GridData | null>;

package/dist/data/solver/allSolvers.js

@@ -1,10 +1,12 @@
 import UniversalSolver from './universal/universalSolver.js';
 import BacktrackSolver from './backtrack/backtrackSolver.js';
 import Z3Solver from './z3/z3Solver.js';
+import CspuzSolver from './cspuz/cspuzSolver.js';
 const allSolvers = new Map();
 function register(prototype) {
     allSolvers.set(prototype.id, prototype);
 }
+register(new CspuzSolver());
 register(new BacktrackSolver());
 register(new UniversalSolver());
 register(new Z3Solver());

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

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

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

@@ -14,7 +14,7 @@ import { instance as minesweeperInstance } from '../../symbols/minesweeperSymbol
 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 connectAllInstance } from '../../rules/connectAllRule.js';
 import EventIteratingSolver from '../eventIteratingSolver.js';
 class BacktrackSolver extends EventIteratingSolver {
     constructor() {
@@ -35,7 +35,7 @@ class BacktrackSolver extends EventIteratingSolver {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: 'Solves puzzles using backtracking with optimizations (blazingly fast). Support most rules and symbols (including underclued).'
+            value: 'Solves puzzles pretty fast using backtracking with optimizations. Support most rules and symbols (including underclued).'
         });
     }
     createWorker() {

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

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

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

@@ -0,0 +1,113 @@
+import { instance as banPatternInstance } from '../../rules/banPatternRule.js';
+import { instance as cellCountInstance } from '../../rules/cellCountRule.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';
+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 { 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 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 EventIteratingSolver from '../eventIteratingSolver.js';
+import GridData from '../../grid.js';
+import { Color } from '../../primitives.js';
+class CspuzSolver extends EventIteratingSolver {
+    constructor() {
+        super(...arguments);
+        Object.defineProperty(this, "id", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 'cspuz'
+        });
+        Object.defineProperty(this, "author", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 'semiexp'
+        });
+        Object.defineProperty(this, "description", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 'A blazingly fast WebAssembly solver that supports most rules and symbols (including underclued). No uniqueness check yet.'
+        });
+    }
+    createWorker() {
+        return new Worker(new URL('./cspuzWorker.js', import.meta.url), {
+            type: 'module',
+        });
+    }
+    isGridSupported(grid) {
+        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) {
+                        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) {
+                            return false;
+                        }
+                    }
+                }
+            }
+        }
+        // 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);
+    }
+    async isEnvironmentSupported() {
+        try {
+            const abortController = new AbortController();
+            for await (const _ of this.solve(GridData.create(['.']), abortController.signal)) {
+                abortController.abort();
+            }
+            return true;
+        }
+        catch (ex) {
+            return false;
+        }
+    }
+}
+Object.defineProperty(CspuzSolver, "supportedInstrs", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: [
+        minesweeperInstance.id,
+        areaNumberInstance.id,
+        letterInstance.id,
+        dartInstance.id,
+        viewpointInstance.id,
+        lotusInstance.id,
+        galaxyInstance.id,
+        connectAllInstance.id,
+        banPatternInstance.id,
+        sameShapeInstance.id,
+        uniqueShapeInstance.id,
+        regionAreaInstance.id,
+        cellCountInstance.id,
+        offByXInstance.id,
+        undercluedInstance.id,
+        symbolsPerRegionInstance.id,
+    ]
+});
+export default CspuzSolver;

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

@@ -0,0 +1 @@
+export {};

package/dist/data/solver/cspuz/cspuzWorker.js

@@ -0,0 +1,44 @@
+import { solveLogicPad } from 'logic-pad-solver-core';
+import { Serializer } from '../../serializer/allSerializers.js';
+import { gridToJson } from './jsonify.js';
+import { instance as undercluedInstance } from '../../rules/undercluedRule.js';
+import { Color } from '../../primitives.js';
+function stringToColor(str) {
+    if (str === 'dark') {
+        return Color.Dark;
+    }
+    else if (str === 'light') {
+        return Color.Light;
+    }
+    else {
+        return Color.Gray;
+    }
+}
+onmessage = e => {
+    const grid = Serializer.parseGrid(e.data);
+    const puzzleData = gridToJson(grid);
+    const solverResult = solveLogicPad(puzzleData, !!grid.findRule(r => r.id === undercluedInstance.id));
+    if (solverResult === null) {
+        postMessage(null);
+    }
+    else if ('error' in solverResult) {
+        throw new Error(solverResult.error);
+    }
+    else {
+        const solution = grid.withTiles(tiles => {
+            for (const [y, row] of solverResult.entries()) {
+                for (const [x, color] of row.entries()) {
+                    tiles[y][x] = tiles[y][x].withColor(stringToColor(color));
+                }
+            }
+            return tiles;
+        });
+        if (solution.resetTiles().colorEquals(solution)) {
+            postMessage(null);
+        }
+        else {
+            postMessage(Serializer.stringifyGrid(solution));
+        }
+    }
+    postMessage(undefined);
+};

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

@@ -0,0 +1,3 @@
+import { PuzzleData } from 'logic-pad-solver-core';
+import GridData from '../../grid.js';
+export declare function gridToJson(grid: GridData): PuzzleData;

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

@@ -0,0 +1,211 @@
+import { Color, Comparison } from '../../primitives.js';
+import BanPatternRule from '../../rules/banPatternRule.js';
+import CellCountRule from '../../rules/cellCountRule.js';
+import ConnectAllRule from '../../rules/connectAllRule.js';
+import OffByXRule from '../../rules/offByXRule.js';
+import RegionAreaRule from '../../rules/regionAreaRule.js';
+import SameShapeRule from '../../rules/sameShapeRule.js';
+import SymbolsPerRegionRule from '../../rules/symbolsPerRegionRule.js';
+import UndercluedRule from '../../rules/undercluedRule.js';
+import UniqueShapeRule from '../../rules/uniqueShapeRule.js';
+import { instance as areaNumberInstance, } from '../../symbols/areaNumberSymbol.js';
+import { instance as dartInstance, } from '../../symbols/dartSymbol.js';
+import { instance as galaxyInstance, } from '../../symbols/galaxySymbol.js';
+import { instance as letterInstance, } from '../../symbols/letterSymbol.js';
+import { instance as lotusInstance, } from '../../symbols/lotusSymbol.js';
+import { instance as minesweeperInstance, } from '../../symbols/minesweeperSymbol.js';
+import { instance as viewpointInstance, } from '../../symbols/viewpointSymbol.js';
+import TileData from '../../tile.js';
+function canonizeTiles(tileData) {
+    const ret = [];
+    for (const row of tileData) {
+        const newRow = [];
+        for (const tile of row) {
+            if (tile.exists) {
+                newRow.push(tile);
+            }
+            else {
+                newRow.push(new TileData(true, false, Color.Gray));
+            }
+        }
+        ret.push(newRow);
+    }
+    return ret;
+}
+export function gridToJson(grid) {
+    const rules = [];
+    for (const rule of grid.rules) {
+        if (rule instanceof ConnectAllRule) {
+            rules.push({
+                type: 'connectAll',
+                color: rule.color,
+            });
+        }
+        else if (rule instanceof BanPatternRule) {
+            rules.push({
+                type: 'forbiddenPattern',
+                pattern: canonizeTiles(rule.pattern.tiles),
+            });
+        }
+        else if (rule instanceof SameShapeRule) {
+            rules.push({
+                type: 'sameShape',
+                color: rule.color,
+            });
+        }
+        else if (rule instanceof UniqueShapeRule) {
+            rules.push({
+                type: 'uniqueShape',
+                color: rule.color,
+            });
+        }
+        else if (rule instanceof RegionAreaRule) {
+            rules.push({
+                type: 'regionArea',
+                color: rule.color,
+                size: rule.size,
+            });
+        }
+        else if (rule instanceof CellCountRule) {
+            rules.push({
+                type: 'cellCount',
+                color: rule.color,
+                count: rule.count,
+            });
+        }
+        else if (rule instanceof OffByXRule) {
+            rules.push({
+                type: 'offByX',
+                number: rule.number,
+            });
+        }
+        else if (rule instanceof UndercluedRule) {
+            continue;
+        }
+        else if (rule instanceof SymbolsPerRegionRule) {
+            let kind;
+            if (rule.comparison === Comparison.Equal) {
+                kind = 'exactly';
+            }
+            else if (rule.comparison === Comparison.AtLeast) {
+                kind = 'atLeast';
+            }
+            else if (rule.comparison === Comparison.AtMost) {
+                kind = 'atMost';
+            }
+            else {
+                throw new Error(`Unknown comparison (${rule.comparison})`);
+            }
+            rules.push({
+                type: 'symbolCount',
+                number: rule.count,
+                kind,
+                color: rule.color,
+            });
+        }
+        else if (rule.necessaryForCompletion) {
+            throw new Error(`Unknown rule type (${rule.explanation})`);
+        }
+    }
+    for (const [rule, symbols] of grid.symbols) {
+        if (rule === minesweeperInstance.id) {
+            rules.push({
+                type: 'minesweeper',
+                tiles: symbols.map(s => ({
+                    x: Math.floor(s.x),
+                    y: Math.floor(s.y),
+                    number: s.number,
+                })),
+            });
+        }
+        else if (rule === areaNumberInstance.id) {
+            rules.push({
+                type: 'number',
+                tiles: symbols.map(s => ({
+                    x: Math.floor(s.x),
+                    y: Math.floor(s.y),
+                    number: s.number,
+                })),
+            });
+        }
+        else if (rule === letterInstance.id) {
+            rules.push({
+                type: 'letter',
+                tiles: symbols.map(s => ({
+                    x: Math.floor(s.x),
+                    y: Math.floor(s.y),
+                    letter: s.letter,
+                })),
+            });
+        }
+        else if (rule === dartInstance.id) {
+            rules.push({
+                type: 'dart',
+                tiles: symbols.map(s => ({
+                    x: Math.floor(s.x),
+                    y: Math.floor(s.y),
+                    orientation: s.orientation,
+                    number: s.number,
+                })),
+            });
+        }
+        else if (rule === viewpointInstance.id) {
+            rules.push({
+                type: 'viewpoint',
+                tiles: symbols.map(s => ({
+                    x: Math.floor(s.x),
+                    y: Math.floor(s.y),
+                    number: s.number,
+                })),
+            });
+        }
+        else if (rule === lotusInstance.id) {
+            const tiles = symbols.map(s => ({
+                x: Math.round(s.x * 2),
+                y: Math.round(s.y * 2),
+                orientation: s.orientation,
+            }));
+            rules.push({
+                type: 'lotus',
+                tiles,
+            });
+        }
+        else if (rule === galaxyInstance.id) {
+            const tiles = symbols.map(s => ({
+                x: Math.round(s.x * 2),
+                y: Math.round(s.y * 2),
+            }));
+            rules.push({
+                type: 'galaxy',
+                tiles,
+            });
+        }
+        else if (symbols.some(s => s.necessaryForCompletion)) {
+            throw new Error(`Unknown symbol type: ${rule}`);
+        }
+    }
+    const connections = grid.connections.edges.map(edge => {
+        return {
+            x1: edge.x1,
+            y1: edge.y1,
+            x2: edge.x2,
+            y2: edge.y2,
+        };
+    });
+    const tiles = grid.tiles.map(row => {
+        return row.map(tile => {
+            return {
+                exists: tile.exists,
+                fixed: tile.fixed,
+                color: tile.color,
+            };
+        });
+    });
+    return {
+        width: grid.width,
+        height: grid.height,
+        connections,
+        tiles,
+        rules,
+    };
+}

package/dist/data/solver/eventIteratingSolver.js

@@ -22,6 +22,10 @@ export default class EventIteratingSolver extends Solver {
                     if (e.data) {
                         push(Serializer.parseGrid(e.data));
                     }
+                    else if (e.data === null) {
+                        push(null);
+                        stop(); // Stop after the first signal for out of solutions
+                    }
                     else {
                         stop();
                     }
@@ -34,7 +38,6 @@ export default class EventIteratingSolver extends Solver {
             for await (const solution of iterator) {
                 yield solution;
             }
-            yield null;
         }
         finally {
             worker.terminate();

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

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

package/dist/data/solver/z3/z3Solver.js

@@ -24,7 +24,7 @@ export default class Z3Solver extends Solver {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: 'Good for confirming that a solution is unique, especially for larger puzzles. It is otherwise slower than most solvers in small to medium-sized puzzles.'
+            value: '(Obsolete) A WebAssembly solver that supports a limited set of rules and symbols.'
         });
         Object.defineProperty(this, "supportsCancellation", {
             enumerable: true,

package/dist/data/symbols/directionLinkerSymbol.js

@@ -153,29 +153,29 @@ class DirectionLinkerSymbol extends Symbol {
         }
         // 1x2
         if (x % 1 === 0) {
-            return [
-                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),
-            ];
+            if (this.linkedDirections[Direction.Up] === Direction.Up &&
+                this.linkedDirections[Direction.Down] === Direction.Down) {
+                return [
+                    makeTurtle({ x, y: y - 0.5 }, { x, y: y - 0.5 }, grid),
+                    makeTurtle({ x, y: y + 0.5 }, { x, y: y + 0.5 }, grid),
+                ];
+            }
+            else {
+                return [makeTurtle({ x, y: y - 0.5 }, { x, y: y + 0.5 }, grid)];
+            }
         }
         // 2x1
         if (y % 1 === 0) {
-            return [
-                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),
-            ];
+            if (this.linkedDirections[Direction.Left] === Direction.Left &&
+                this.linkedDirections[Direction.Right] === Direction.Right) {
+                return [
+                    makeTurtle({ x: x - 0.5, y }, { x: x - 0.5, y }, grid),
+                    makeTurtle({ x: x + 0.5, y }, { x: x + 0.5, y }, grid),
+                ];
+            }
+            else {
+                return [makeTurtle({ x: x - 0.5, y }, { x: x + 0.5, y }, grid)];
+            }
         }
         // 2x2
         if (this.linkedDirections[Direction.Left] === Direction.Left &&

package/dist/index.d.ts

@@ -67,6 +67,8 @@ import LotusBTModule from './data/solver/backtrack/symbols/lotus.js';
 import MinesweeperBTModule from './data/solver/backtrack/symbols/minesweeper.js';
 import MyopiaBTModule from './data/solver/backtrack/symbols/myopia.js';
 import ViewpointBTModule from './data/solver/backtrack/symbols/viewpoint.js';
+import CspuzSolver from './data/solver/cspuz/cspuzSolver.js';
+import { gridToJson } from './data/solver/cspuz/jsonify.js';
 import EventIteratingSolver from './data/solver/eventIteratingSolver.js';
 import Solver from './data/solver/solver.js';
 import UniversalSolver from './data/solver/universal/universalSolver.js';
@@ -104,4 +106,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, isSameEdge, maxBy, minBy, move, orientationToRotation, resize, unescape, isEventHandler, handlesFinalValidation, handlesGetTile, handlesGridChange, handlesGridResize, handlesSetGrid, invokeSetGrid, handlesSymbolDisplay, handlesSymbolValidation, GridData, NEIGHBOR_OFFSETS, GridConnections, GridZones, Instruction, COMPARISONS, Color, Comparison, DIRECTIONS, Direction, MajorRule, Mode, ORIENTATIONS, Orientation, State, WRAPPINGS, Wrapping, directionToggle, orientationToggle, MetadataSchema, PuzzleSchema, BanPatternRule, CellCountPerZoneRule, CellCountRule, CompletePatternRule, ConnectAllRule, CustomRule, ForesightRule, allRules, LyingSymbolRule, ControlLine, Row, MusicGridRule, MysteryRule, OffByXRule, PerfectionRule, RegionAreaRule, RegionShapeRule, Rule, SameShapeRule, SymbolsPerRegionRule, UndercluedRule, UniqueShapeRule, WrapAroundRule, 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, FocusBTModule, GalaxyBTModule, LetterBTModule, LotusBTModule, MinesweeperBTModule, MyopiaBTModule, ViewpointBTModule, EventIteratingSolver, Solver, UniversalSolver, AreaNumberModule, CellCountModule, ConnectAllModule, DartModule, allZ3Modules, LetterModule, MyopiaModule, RegionAreaModule, ViewpointModule, Z3Module, convertDirection, Z3Solver, Z3SolverContext, AreaNumberSymbol, CustomIconSymbol, CustomSymbol, CustomTextSymbol, DartSymbol, DirectionLinkerSymbol, FocusSymbol, 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, isSameEdge, maxBy, minBy, move, orientationToRotation, resize, unescape, isEventHandler, handlesFinalValidation, handlesGetTile, handlesGridChange, handlesGridResize, handlesSetGrid, invokeSetGrid, handlesSymbolDisplay, handlesSymbolValidation, GridData, NEIGHBOR_OFFSETS, GridConnections, GridZones, Instruction, COMPARISONS, Color, Comparison, DIRECTIONS, Direction, MajorRule, Mode, ORIENTATIONS, Orientation, State, WRAPPINGS, Wrapping, directionToggle, orientationToggle, MetadataSchema, PuzzleSchema, BanPatternRule, CellCountPerZoneRule, CellCountRule, CompletePatternRule, ConnectAllRule, CustomRule, ForesightRule, allRules, LyingSymbolRule, ControlLine, Row, MusicGridRule, MysteryRule, OffByXRule, PerfectionRule, RegionAreaRule, RegionShapeRule, Rule, SameShapeRule, SymbolsPerRegionRule, UndercluedRule, UniqueShapeRule, WrapAroundRule, 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, FocusBTModule, GalaxyBTModule, LetterBTModule, LotusBTModule, MinesweeperBTModule, MyopiaBTModule, ViewpointBTModule, CspuzSolver, gridToJson, EventIteratingSolver, Solver, UniversalSolver, AreaNumberModule, CellCountModule, ConnectAllModule, DartModule, allZ3Modules, LetterModule, MyopiaModule, RegionAreaModule, ViewpointModule, Z3Module, convertDirection, Z3Solver, Z3SolverContext, AreaNumberSymbol, CustomIconSymbol, CustomSymbol, CustomTextSymbol, DartSymbol, DirectionLinkerSymbol, FocusSymbol, GalaxySymbol, HiddenSymbol, allSymbols, LetterSymbol, LotusSymbol, MinesweeperSymbol, MultiEntrySymbol, MyopiaSymbol, NumberSymbol, Symbol, ViewpointSymbol, TileData, TileConnections, validateGrid, aggregateState, applyFinalOverrides, };

package/dist/index.js

@@ -70,6 +70,8 @@ import LotusBTModule from './data/solver/backtrack/symbols/lotus.js';
 import MinesweeperBTModule from './data/solver/backtrack/symbols/minesweeper.js';
 import MyopiaBTModule from './data/solver/backtrack/symbols/myopia.js';
 import ViewpointBTModule from './data/solver/backtrack/symbols/viewpoint.js';
+import CspuzSolver from './data/solver/cspuz/cspuzSolver.js';
+import { gridToJson } from './data/solver/cspuz/jsonify.js';
 import EventIteratingSolver from './data/solver/eventIteratingSolver.js';
 import Solver from './data/solver/solver.js';
 import UniversalSolver from './data/solver/universal/universalSolver.js';
@@ -107,4 +109,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, isSameEdge, maxBy, minBy, move, orientationToRotation, resize, unescape, isEventHandler, handlesFinalValidation, handlesGetTile, handlesGridChange, handlesGridResize, handlesSetGrid, invokeSetGrid, handlesSymbolDisplay, handlesSymbolValidation, GridData, NEIGHBOR_OFFSETS, GridConnections, GridZones, Instruction, COMPARISONS, Color, Comparison, DIRECTIONS, Direction, MajorRule, Mode, ORIENTATIONS, Orientation, State, WRAPPINGS, Wrapping, directionToggle, orientationToggle, MetadataSchema, PuzzleSchema, BanPatternRule, CellCountPerZoneRule, CellCountRule, CompletePatternRule, ConnectAllRule, CustomRule, ForesightRule, allRules, LyingSymbolRule, ControlLine, Row, MusicGridRule, MysteryRule, OffByXRule, PerfectionRule, RegionAreaRule, RegionShapeRule, Rule, SameShapeRule, SymbolsPerRegionRule, UndercluedRule, UniqueShapeRule, WrapAroundRule, 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, FocusBTModule, GalaxyBTModule, LetterBTModule, LotusBTModule, MinesweeperBTModule, MyopiaBTModule, ViewpointBTModule, EventIteratingSolver, Solver, UniversalSolver, AreaNumberModule, CellCountModule, ConnectAllModule, DartModule, allZ3Modules, LetterModule, MyopiaModule, RegionAreaModule, ViewpointModule, Z3Module, convertDirection, Z3Solver, Z3SolverContext, AreaNumberSymbol, CustomIconSymbol, CustomSymbol, CustomTextSymbol, DartSymbol, DirectionLinkerSymbol, FocusSymbol, 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, isSameEdge, maxBy, minBy, move, orientationToRotation, resize, unescape, isEventHandler, handlesFinalValidation, handlesGetTile, handlesGridChange, handlesGridResize, handlesSetGrid, invokeSetGrid, handlesSymbolDisplay, handlesSymbolValidation, GridData, NEIGHBOR_OFFSETS, GridConnections, GridZones, Instruction, COMPARISONS, Color, Comparison, DIRECTIONS, Direction, MajorRule, Mode, ORIENTATIONS, Orientation, State, WRAPPINGS, Wrapping, directionToggle, orientationToggle, MetadataSchema, PuzzleSchema, BanPatternRule, CellCountPerZoneRule, CellCountRule, CompletePatternRule, ConnectAllRule, CustomRule, ForesightRule, allRules, LyingSymbolRule, ControlLine, Row, MusicGridRule, MysteryRule, OffByXRule, PerfectionRule, RegionAreaRule, RegionShapeRule, Rule, SameShapeRule, SymbolsPerRegionRule, UndercluedRule, UniqueShapeRule, WrapAroundRule, 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, FocusBTModule, GalaxyBTModule, LetterBTModule, LotusBTModule, MinesweeperBTModule, MyopiaBTModule, ViewpointBTModule, CspuzSolver, gridToJson, EventIteratingSolver, Solver, UniversalSolver, AreaNumberModule, CellCountModule, ConnectAllModule, DartModule, allZ3Modules, LetterModule, MyopiaModule, RegionAreaModule, ViewpointModule, Z3Module, convertDirection, Z3Solver, Z3SolverContext, AreaNumberSymbol, CustomIconSymbol, CustomSymbol, CustomTextSymbol, DartSymbol, DirectionLinkerSymbol, FocusSymbol, 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.9.0",
+  "version": "0.10.1",
   "type": "module",
   "files": [
     "dist",