@logic-pad/core 0.23.2 → 0.25.0

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

@@ -1929,6 +1929,28 @@ declare global {
     withVisible(visible: boolean): this;
     static cleanSolution(solution: GridData, baseGrid?: GridData): GridData;
   }
+  export declare class NoLoopsRule extends Rule {
+    readonly color: Color;
+    readonly title = 'No Loops';
+    private static readonly CONFIGS;
+    private static readonly EXAMPLE_GRID_LIGHT;
+    private static readonly EXAMPLE_GRID_DARK;
+    private static readonly SEARCH_VARIANTS;
+    /**
+     * **No loops in <color> cells**
+     *
+     * @param color - The color of the cells to check.
+     */
+    constructor(color: Color);
+    get id(): string;
+    get explanation(): string;
+    get configs(): readonly AnyConfig[] | null;
+    createExampleGrid(): GridData;
+    get searchVariants(): SearchVariant[];
+    validateGrid(grid: GridData): RuleState;
+    copyWith({ color }: { color?: Color }): this;
+    withColor(color: Color): this;
+  }
   export declare class OffByXRule
     extends Rule
     implements SymbolValidationHandler
@@ -3162,6 +3184,37 @@ declare global {
     withText(text: string): this;
     withRotation(rotation: number): this;
   }
+  export declare class EveryLetterSymbol extends Symbol$1 {
+    readonly x: number;
+    readonly y: number;
+    readonly letter: string;
+    readonly title = 'Hollow Letter';
+    private static readonly CONFIGS;
+    private static readonly EXAMPLE_GRID;
+    /**
+     * **Include each Hollow Letter once per region**
+     *
+     * @param x - The x-coordinate of the symbol.
+     * @param y - The y-coordinate of the symbol.
+     * @param letter - The letter of the symbol.
+     */
+    constructor(x: number, y: number, letter: string);
+    get id(): string;
+    get explanation(): string;
+    get configs(): readonly AnyConfig[] | null;
+    createExampleGrid(): GridData;
+    validateSymbol(grid: GridData): State;
+    copyWith({
+      x,
+      y,
+      letter,
+    }: {
+      x?: number;
+      y?: number;
+      letter?: string;
+    }): this;
+    withLetter(letter: string): this;
+  }
   export declare class HiddenSymbol
     extends Symbol$1
     implements SymbolDisplayHandler

package/dist/benchmark/helper.d.ts

@@ -0,0 +1,21 @@
+import { Puzzle } from '../src/data/puzzle.js';
+import CompressorBase from '../src/data/serializer/compressor/compressorBase.js';
+declare class BunCompressor extends CompressorBase {
+    get id(): string;
+    compress(input: string): Promise<string>;
+    decompress(input: string): Promise<string>;
+}
+export declare const bunCompressor: BunCompressor;
+export interface PuzzleEntry {
+    pid: number;
+    difficulty: number;
+    puzzleLink: string;
+}
+export interface BenchmarkEntry {
+    pid: number;
+    supported: boolean;
+    solveTime: number;
+    solveCorrect: boolean;
+}
+export declare function parseLink(link: string): Promise<Puzzle>;
+export {};

package/dist/benchmark/helper.js

@@ -0,0 +1,34 @@
+import { Serializer } from '../src/data/serializer/allSerializers.js';
+import { encode, decode } from 'uint8-to-base64';
+import CompressorBase from '../src/data/serializer/compressor/compressorBase.js';
+const decoder = new TextDecoder();
+const encoder = new TextEncoder();
+class BunCompressor extends CompressorBase {
+    get id() {
+        return 'dfl';
+    }
+    compress(input) {
+        const data = Bun.deflateSync(encoder.encode(input), {
+            library: 'libdeflate',
+            level: 12,
+        });
+        return Promise.resolve(`${this.id}_${encode(data).replace(/\+/g, '-').replace(/\//g, '_')}`);
+    }
+    decompress(input) {
+        const data = decode(input.replace(`${this.id}_`, '').replace(/-/g, '+').replace(/_/g, '/'));
+        const result = Bun.inflateSync(data, {
+            library: 'libdeflate',
+            level: 12,
+        });
+        return Promise.resolve(decoder.decode(result));
+    }
+}
+export const bunCompressor = new BunCompressor();
+export async function parseLink(link) {
+    const url = new URL(link);
+    const data = url.searchParams.get('d');
+    if (data === null) {
+        throw new Error('Missing data parameter');
+    }
+    return Serializer.parsePuzzle(await bunCompressor.decompress(data));
+}

package/dist/benchmark/prepareBench.js

@@ -0,0 +1,140 @@
+import { parseArgs } from 'util';
+import { allSolvers } from '../src/data/solver/allSolvers.js';
+import { parseLink } from './helper.js';
+import PQueue from 'p-queue';
+const allPuzzlesPath = 'benchmark/data/all_puzzles_logic_pad.json';
+const { values, positionals } = parseArgs({
+    args: Bun.argv,
+    options: {
+        maxTime: {
+            type: 'string',
+            default: '10',
+            short: 't',
+        },
+        maxCount: {
+            type: 'string',
+            default: '99999',
+            short: 'c',
+        },
+        concurrency: {
+            type: 'string',
+            default: '4',
+            short: 'n',
+        },
+        help: {
+            type: 'boolean',
+            short: 'h',
+        },
+    },
+    strict: true,
+    allowPositionals: true,
+});
+positionals.splice(0, 2); // Remove "bun" and script name
+if (values.help || positionals.length !== 1) {
+    console.log(`
+Usage: bun bench:prepare <solver> [options]
+
+Options:
+  -t, --maxTime <number>      Maximum seconds allowed for each solve (default: 10)
+  -c, --maxCount <number>     Maximum number of puzzles included (default: 100)
+  -n, --concurrency <number>  Number of solves to run concurrently (default: 4)
+  -h, --help                  Show this help message
+
+Solver:
+  Name of the solver to benchmark. Available solvers are:
+${[...allSolvers.keys()].map(s => `    - ${s}`).join('\n')}
+`);
+    process.exit(0);
+}
+const maxTime = parseFloat(values.maxTime) * 1000;
+const maxCount = parseInt(values.maxCount);
+const solverName = positionals[0];
+const solver = allSolvers.get(solverName);
+if (!solver) {
+    console.error(`Error: Solver "${solverName}" not found.`);
+    process.exit(1);
+}
+const allPuzzles = (await Bun.file(allPuzzlesPath).json());
+allPuzzles.sort(() => Math.random() - 0.5);
+const results = [];
+const pqueue = new PQueue({ concurrency: 4 });
+function printEntry(benchmarkEntry, entryId, solverId, pid) {
+    if (benchmarkEntry.supported) {
+        console.log(`${solverId}\t| ${entryId} / ${allPuzzles.length}\t| ${pid}\t| ${Number.isNaN(benchmarkEntry.solveTime)
+            ? 'timeout'
+            : `${benchmarkEntry.solveTime.toFixed(0)}ms`} ${benchmarkEntry.solveCorrect ? '✓' : '✗'}`);
+    }
+    else {
+        console.log(`${solverId}\t| ${entryId} / ${allPuzzles.length}\t| ${pid}\t| unsupported`);
+    }
+}
+console.log('Available\t| Selected\t| PID\t| Result');
+for (const entry of allPuzzles) {
+    if (results.filter(r => r.result.solveCorrect && r.result.supported).length >=
+        maxCount) {
+        break;
+    }
+    const puzzle = await parseLink(entry.puzzleLink);
+    void pqueue.add(async () => {
+        if (!solver.isGridSupported(puzzle.grid)) {
+            results.push({
+                puzzle: entry,
+                result: {
+                    pid: entry.pid,
+                    supported: false,
+                    solveTime: Number.NaN,
+                    solveCorrect: false,
+                },
+            });
+            printEntry(results[results.length - 1].result, results.length, solverName, entry.pid);
+            return;
+        }
+        const startTime = performance.now();
+        const abortController = new AbortController();
+        const benchmarkEntry = {
+            pid: entry.pid,
+            supported: true,
+            solveTime: Number.NaN,
+            solveCorrect: false,
+        };
+        let step = 0;
+        const handle = setTimeout(() => {
+            abortController.abort();
+        }, maxTime);
+        try {
+            for await (const solution of solver.solve(puzzle.grid, abortController.signal)) {
+                if (step === 0) {
+                    const solveCorrect = solution?.colorEquals(puzzle.solution) ?? false;
+                    if (!solveCorrect)
+                        break;
+                }
+                else {
+                    benchmarkEntry.solveCorrect = solution === null;
+                    if (benchmarkEntry.solveCorrect)
+                        benchmarkEntry.solveTime = performance.now() - startTime;
+                    break;
+                }
+                step++;
+            }
+        }
+        catch {
+            benchmarkEntry.solveCorrect = false;
+        }
+        clearTimeout(handle);
+        results.push({ puzzle: entry, result: benchmarkEntry });
+        printEntry(results[results.length - 1].result, results.length, solverName, entry.pid);
+    });
+}
+await pqueue.onIdle();
+const selectedPuzzles = results.filter(r => r.result.solveCorrect && r.result.supported);
+const benchmarkEntries = selectedPuzzles.map(r => r.result);
+await Bun.write(`benchmark/data/bench_${solverName}_puzzles.json`, JSON.stringify(selectedPuzzles.map(r => r.puzzle), null, 2));
+await Bun.write(`benchmark/data/bench_${solverName}_results.json`, JSON.stringify(benchmarkEntries, null, 2));
+console.log(`
+Benchmark preparation completed. Selected ${selectedPuzzles.length} puzzles.
+
+- Solver: ${solverName}   Max Time: ${maxTime}ms   Max Count: ${maxCount}
+- Average time: ${benchmarkEntries.filter(e => !Number.isNaN(e.solveTime)).reduce((a, b) => a + b.solveTime, 0) / benchmarkEntries.filter(e => !Number.isNaN(e.solveTime)).length}ms
+- Number of timeouts: ${benchmarkEntries.filter(e => Number.isNaN(e.solveTime)).length}
+- Solve correctness: ${benchmarkEntries.filter(e => e.solveCorrect).length} / ${benchmarkEntries.length}
+`);

package/dist/benchmark/runBench.js

@@ -0,0 +1,206 @@
+import { parseArgs } from 'util';
+import { allSolvers } from '../src/data/solver/allSolvers.js';
+import { parseLink } from './helper.js';
+import PQueue from 'p-queue';
+const { values, positionals } = parseArgs({
+    args: Bun.argv,
+    options: {
+        maxTime: {
+            type: 'string',
+            default: '10',
+            short: 't',
+        },
+        maxCount: {
+            type: 'string',
+            default: '99999',
+            short: 'c',
+        },
+        concurrency: {
+            type: 'string',
+            default: '4',
+            short: 'n',
+        },
+        help: {
+            type: 'boolean',
+            short: 'h',
+        },
+    },
+    strict: true,
+    allowPositionals: true,
+});
+positionals.splice(0, 2); // Remove "bun" and script name
+if (values.help || positionals.length === 0) {
+    console.log(`
+Usage: bun bench:run <solver> [options]
+
+Options:
+  -t, --maxTime <number>       Maximum seconds allowed for each solve (default: 10)
+  -c, --maxCount <number>      Maximum number of puzzles included (default: 100)
+  -n, --concurrency <number>   Number of solves to run concurrently (default: 4)
+  -h, --help                   Show this help message
+
+Solvers available for benchmarking:
+${[...allSolvers.keys()].map(s => `    - ${s}`).join('\n')}
+`);
+    process.exit(0);
+}
+const maxTime = parseFloat(values.maxTime) * 1000;
+const maxCount = parseInt(values.maxCount);
+const concurrency = parseInt(values.concurrency);
+for (const name of positionals) {
+    if (!allSolvers.has(name)) {
+        console.error(`Error: Solver "${name}" not found.`);
+        process.exit(1);
+    }
+}
+const allPuzzles = (await Bun.file(`benchmark/data/bench_${positionals[0]}_puzzles.json`).json());
+allPuzzles.sort(() => Math.random() - 0.5);
+allPuzzles.splice(maxCount);
+const benchmarkEntries = Object.fromEntries(positionals.map(name => [
+    name,
+    allPuzzles.map(p => ({
+        pid: p.pid,
+        supported: false,
+        solveTime: Number.NaN,
+        solveCorrect: false,
+    })),
+]));
+const pqueue = new PQueue({ concurrency });
+function printEntry(benchmarkEntry, entryId, solverId, pid) {
+    if (benchmarkEntry.supported) {
+        console.log(`${solverId}\t| ${entryId} / ${allPuzzles.length}\t| ${pid}\t| ${Number.isNaN(benchmarkEntry.solveTime)
+            ? 'timeout'
+            : `${benchmarkEntry.solveTime.toFixed(0)}ms`} ${benchmarkEntry.solveCorrect ? '✓' : '✗'}`);
+    }
+    else {
+        console.log(`${solverId}\t| ${entryId} / ${allPuzzles.length}\t| ${pid}\t| unsupported`);
+    }
+}
+console.log('Solver     \t| Trial     \t| PID\t| Result');
+console.log();
+for (let i = 0; i < allPuzzles.length; i++) {
+    const entry = allPuzzles[i];
+    const solvers = positionals.slice().sort(() => Math.random() - 0.5);
+    const puzzle = await parseLink(entry.puzzleLink);
+    for (const solverId of solvers) {
+        const solver = allSolvers.get(solverId);
+        void pqueue.add(async () => {
+            if (!solver.isGridSupported(puzzle.grid)) {
+                benchmarkEntries[solverId][i] = {
+                    pid: entry.pid,
+                    supported: false,
+                    solveTime: Number.NaN,
+                    solveCorrect: false,
+                };
+                printEntry(benchmarkEntries[solverId][i], i + 1, solverId, entry.pid);
+                return;
+            }
+            const startTime = performance.now();
+            const abortController = new AbortController();
+            const benchmarkEntry = {
+                pid: entry.pid,
+                supported: true,
+                solveTime: Number.NaN,
+                solveCorrect: false,
+            };
+            let step = 0;
+            const handle = setTimeout(() => {
+                abortController.abort();
+            }, maxTime);
+            try {
+                for await (const solution of solver.solve(puzzle.grid, abortController.signal)) {
+                    if (step === 0) {
+                        const solveCorrect = solution?.colorEquals(puzzle.solution) ?? false;
+                        if (!solveCorrect)
+                            break;
+                    }
+                    else {
+                        benchmarkEntry.solveCorrect = solution === null;
+                        if (benchmarkEntry.solveCorrect)
+                            benchmarkEntry.solveTime = performance.now() - startTime;
+                        break;
+                    }
+                    step++;
+                }
+            }
+            catch {
+                benchmarkEntry.solveCorrect = false;
+            }
+            clearTimeout(handle);
+            benchmarkEntries[solverId][i] = benchmarkEntry;
+            printEntry(benchmarkEntry, i + 1, solverId, entry.pid);
+        });
+    }
+}
+await pqueue.onIdle();
+const results = positionals.map(name => ({
+    solver: name,
+    fastestCount: 0,
+    solve25: 0,
+    solve50: 0,
+    solve75: 0,
+    solveSD: 0,
+    unsupportedCount: 0,
+    incorrectCount: 0,
+}));
+for (let i = 0; i < benchmarkEntries[positionals[0]].length; i++) {
+    let fastestSolveTime = Number.POSITIVE_INFINITY;
+    let fastestSolverIndex = null;
+    for (let j = 0; j < positionals.length; j++) {
+        const entry = benchmarkEntries[positionals[j]][i];
+        if (!entry.supported) {
+            results[j].unsupportedCount++;
+            continue;
+        }
+        if (entry.solveCorrect && !Number.isNaN(entry.solveTime)) {
+            if (entry.solveTime < fastestSolveTime) {
+                fastestSolveTime = entry.solveTime;
+                fastestSolverIndex = j;
+            }
+        }
+        else {
+            results[j].incorrectCount++;
+        }
+    }
+    if (fastestSolverIndex !== null) {
+        results[fastestSolverIndex].fastestCount++;
+    }
+}
+for (let j = 0; j < positionals.length; j++) {
+    const entries = benchmarkEntries[positionals[j]].filter(e => e.supported && e.solveCorrect && !Number.isNaN(e.solveTime));
+    // 25th percentile
+    const times = entries.map(e => e.solveTime).sort((a, b) => a - b);
+    results[j].solve25 =
+        times.length === 0
+            ? Number.NaN
+            : times[Math.floor((times.length - 1) * 0.25)];
+    // 50th percentile (median)
+    results[j].solve50 =
+        times.length === 0
+            ? Number.NaN
+            : times[Math.floor((times.length - 1) * 0.5)];
+    // 75th percentile
+    results[j].solve75 =
+        times.length === 0
+            ? Number.NaN
+            : times[Math.floor((times.length - 1) * 0.75)];
+    // Standard deviation
+    const mean = times.reduce((sum, time) => sum + time, 0) / (times.length || 1);
+    const variance = times.reduce((sum, time) => sum + (time - mean) ** 2, 0) /
+        (times.length || 1);
+    results[j].solveSD = Math.sqrt(variance);
+}
+console.log('\nBenchmark Results:');
+for (const result of results) {
+    console.log(`
+${result.solver}:
+  Fastest Solves: ${result.fastestCount}
+  Solve time:
+    P25: ${Number.isNaN(result.solve25) ? 'N/A' : `${result.solve25.toFixed(2)}ms`}
+    P50: ${Number.isNaN(result.solve50) ? 'N/A' : `${result.solve50.toFixed(2)}ms`}
+    P75: ${Number.isNaN(result.solve75) ? 'N/A' : `${result.solve75.toFixed(2)}ms`}
+    SD:  ${Number.isNaN(result.solveSD) ? 'N/A' : `${result.solveSD.toFixed(2)}ms`}
+  Unsupported Puzzles: ${result.unsupportedCount}
+  Incorrect Solutions: ${result.incorrectCount}
+`);
+}

package/dist/{data → src/data}/dataHelper.js

@@ -199,19 +199,11 @@ export function unescape(text, escapeCharacters = '=,:|') {
     return result + text.substring(index);
 }
 export class CachedAccess {
+    getter;
+    static UNCACHED = Symbol('uncached');
+    cache = CachedAccess.UNCACHED;
     constructor(getter) {
-        Object.defineProperty(this, "getter", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: getter
-        });
-        Object.defineProperty(this, "cache", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: CachedAccess.UNCACHED
-        });
+        this.getter = getter;
     }
     static of(getter) {
         return new CachedAccess(getter);
@@ -223,9 +215,3 @@ export class CachedAccess {
         return this.cache;
     }
 }
-Object.defineProperty(CachedAccess, "UNCACHED", {
-    enumerable: true,
-    configurable: true,
-    writable: true,
-    value: Symbol('uncached')
-});

package/dist/{data → src/data}/grid.js

@@ -13,6 +13,19 @@ export const NEIGHBOR_OFFSETS = [
     { x: 0, y: 1 },
 ];
 export default class GridData {
+    width;
+    height;
+    tiles;
+    connections;
+    zones;
+    symbols;
+    rules;
+    // Important rules are cached for quick access
+    /* eslint-disable @typescript-eslint/no-unsafe-enum-comparison */
+    musicGrid = CachedAccess.of(() => this.findRule(rule => rule.id === MajorRule.MusicGrid));
+    completePattern = CachedAccess.of(() => this.findRule(rule => rule.id === MajorRule.CompletePattern));
+    underclued = CachedAccess.of(() => this.findRule(rule => rule.id === MajorRule.Underclued));
+    wrapAround = CachedAccess.of(() => this.findRule(rule => rule.id === MajorRule.WrapAround));
     /* eslint-enable @typescript-eslint/no-unsafe-enum-comparison */
     /**
      * Create a new grid with tiles, connections, symbols and rules.
@@ -26,74 +39,8 @@ export default class GridData {
      * @param rules The rules of the grid.
      */
     constructor(width, height, tiles, connections, zones, symbols, rules) {
-        Object.defineProperty(this, "width", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: width
-        });
-        Object.defineProperty(this, "height", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: height
-        });
-        Object.defineProperty(this, "tiles", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "connections", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "zones", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "symbols", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "rules", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        // Important rules are cached for quick access
-        /* eslint-disable @typescript-eslint/no-unsafe-enum-comparison */
-        Object.defineProperty(this, "musicGrid", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: CachedAccess.of(() => this.findRule(rule => rule.id === MajorRule.MusicGrid))
-        });
-        Object.defineProperty(this, "completePattern", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: CachedAccess.of(() => this.findRule(rule => rule.id === MajorRule.CompletePattern))
-        });
-        Object.defineProperty(this, "underclued", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: CachedAccess.of(() => this.findRule(rule => rule.id === MajorRule.Underclued))
-        });
-        Object.defineProperty(this, "wrapAround", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: CachedAccess.of(() => this.findRule(rule => rule.id === MajorRule.WrapAround))
-        });
+        this.width = width;
+        this.height = height;
         this.width = width;
         this.height = height;
         this.tiles = tiles ?? array(width, height, () => TileData.empty());
@@ -906,10 +853,15 @@ export default class GridData {
         })));
         const symbols = new Map();
         for (const [id, symbolList] of this.symbols) {
-            const newSymbolList = symbolList.filter(symbol => symbol.x >= origin.x &&
+            const newSymbolList = symbolList
+                .filter(symbol => symbol.x >= origin.x &&
                 symbol.y >= origin.y &&
                 symbol.x < origin.x + width &&
-                symbol.y < origin.y + height);
+                symbol.y < origin.y + height)
+                .map(symbol => symbol.copyWith({
+                x: symbol.x - origin.x,
+                y: symbol.y - origin.y,
+            }));
             if (newSymbolList.length > 0)
                 symbols.set(id, newSymbolList);
         }

package/dist/{data → src/data}/gridZones.js

@@ -1,12 +1,7 @@
 import { isSameEdge } from './dataHelper.js';
 export default class GridZones {
+    edges;
     constructor(edges) {
-        Object.defineProperty(this, "edges", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
         this.edges = GridZones.deduplicateEdges(edges ?? []);
     }
     addEdge(edge) {