@logic-pad/core 0.10.1 → 0.11.0

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

@@ -160,6 +160,11 @@ declare global {
      * @returns The deduplicated array of edges.
      */
     static deduplicateEdges(edges: readonly Edge[]): readonly Edge[];
+    static validateEdges(
+      connections: GridZones,
+      width: number,
+      height: number
+    ): GridZones;
     insertColumn(index: number): GridZones;
     insertRow(index: number): GridZones;
     removeColumn(index: number): GridZones;
@@ -206,6 +211,11 @@ declare global {
      * @returns The created connections. You can apply this to a GridData object using GridData.withConnections.
      */
     static create(array: string[]): GridConnections;
+    static validateEdges(
+      connections: GridConnections,
+      width: number,
+      height: number
+    ): GridConnections;
     insertColumn(index: number): GridConnections;
     insertRow(index: number): GridConnections;
     removeColumn(index: number): GridConnections;
@@ -1495,6 +1505,10 @@ declare global {
   ): Shape;
   export declare function getShapeVariants(shape: Shape): Shape[];
   export declare function normalizeShape(shape: Shape): Shape;
+  export declare function sanitizePatternGrid(
+    pattern: GridData,
+    tileMapper?: (tile: TileData) => TileData
+  ): GridData;
   export declare class BanPatternRule extends Rule {
     private static readonly EXAMPLE_GRID;
     private static readonly CONFIGS;
@@ -1583,6 +1597,46 @@ declare global {
     copyWith({ color }: { color?: Color }): this;
     withColor(color: Color): this;
   }
+  export type ShapeRegions = {
+    regions: {
+      positions: Position$1[];
+      shape: Shape;
+      count: number;
+    }[];
+    complete: boolean;
+  };
+  export declare abstract class RegionShapeRule extends Rule {
+    readonly color: Color;
+    /**
+     * @param color - The color of the regions to compare.
+     */
+    constructor(color: Color);
+    protected getShapeRegions(grid: GridData): ShapeRegions;
+    withColor(color: Color): this;
+  }
+  export declare class ContainsShapeRule extends RegionShapeRule {
+    private static readonly EXAMPLE_GRID_LIGHT;
+    private static readonly EXAMPLE_GRID_DARK;
+    private static readonly CONFIGS;
+    private static readonly SEARCH_VARIANTS;
+    readonly pattern: GridData;
+    readonly cache: Shape[];
+    /**
+     * **All <color> areas must contain this pattern**
+     *
+     * @param color - The color of the regions to compare.
+     * @param pattern - GridData representing the required pattern. Only non-gray tiles are considered.
+     */
+    constructor(color: Color, pattern: GridData);
+    get id(): string;
+    get explanation(): string;
+    get configs(): readonly AnyConfig[] | null;
+    createExampleGrid(): GridData;
+    get searchVariants(): SearchVariant[];
+    validateGrid(grid: GridData): RuleState;
+    copyWith({ color, pattern }: { color?: Color; pattern?: GridData }): this;
+    withPattern(pattern: GridData): this;
+  }
   export declare class CustomRule extends Rule {
     readonly description: string;
     readonly grid: GridData;
@@ -1825,23 +1879,6 @@ declare global {
     withColor(color: Color): this;
     withSize(size: number): this;
   }
-  export type ShapeRegions = {
-    regions: {
-      positions: Position$1[];
-      shape: Shape;
-      count: number;
-    }[];
-    complete: boolean;
-  };
-  export declare abstract class RegionShapeRule extends Rule {
-    readonly color: Color;
-    /**
-     * @param color - The color of the regions to compare.
-     */
-    constructor(color: Color);
-    protected getShapeRegions(grid: GridData): ShapeRegions;
-    withColor(color: Color): this;
-  }
   export declare class SameShapeRule extends RegionShapeRule {
     private static readonly CONFIGS;
     private static readonly EXAMPLE_GRID_LIGHT;
@@ -2087,7 +2124,8 @@ declare global {
      *
      * @returns A promise that resolves to `true` if the environment is supported, or `false` otherwise.
      */
-    isEnvironmentSupported(): Promise<boolean>;
+    protected isEnvironmentSupported(): Promise<boolean>;
+    readonly environmentCheck: CachedAccess<Promise<boolean>>;
     /**
      * Check if the solver supports the given instruction. This is used to render a small indication in the UI for each
      * instruction in the editor.
@@ -2108,9 +2146,29 @@ declare global {
     isGridSupported(grid: GridData): boolean;
   }
   export declare const allSolvers: Map<string, Solver>;
+  export declare class AutoSolver extends Solver {
+    readonly id = 'auto';
+    readonly author = 'various contributors';
+    readonly description =
+      'Automatically select the fastest solver based on supported instructions and environment.';
+    readonly supportsCancellation = true;
+    private static readonly nonAdditiveInstructions;
+    isGridSupported(grid: GridData): boolean;
+    isInstructionSupported(instructionId: string): boolean;
+    protected isEnvironmentSupported(): Promise<boolean>;
+    private fillSolution;
+    private fixGrid;
+    private solveWithProgress;
+    private solveOne;
+    solve(
+      grid: GridData,
+      abortSignal?: AbortSignal | undefined
+    ): AsyncGenerator<GridData | null>;
+  }
   export declare abstract class EventIteratingSolver extends Solver {
     readonly supportsCancellation = true;
     protected abstract createWorker(): Worker;
+    protected isEnvironmentSupported(): Promise<boolean>;
     solve(
       grid: GridData,
       abortSignal?: AbortSignal
@@ -2635,7 +2693,7 @@ declare global {
     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.';
+      'A blazingly fast WebAssembly solver that supports most rules and symbols (including underclued).';
     protected createWorker(): Worker;
     isGridSupported(grid: GridData): boolean;
     isInstructionSupported(instructionId: string): boolean;
@@ -2739,7 +2797,7 @@ declare global {
     readonly description =
       '(Obsolete) A WebAssembly solver that supports a limited set of rules and symbols.';
     readonly supportsCancellation = false;
-    isEnvironmentSupported(): Promise<boolean>;
+    protected isEnvironmentSupported(): Promise<boolean>;
     solve(grid: GridData): AsyncGenerator<GridData | null>;
     isInstructionSupported(instructionId: string): boolean;
     isGridSupported(grid: GridData): boolean;

package/dist/data/grid.js

@@ -109,7 +109,9 @@ export default class GridData {
                 : new Map();
             // do not deduplicate all rules because it makes for bad editor experience
             const newRules = rules ? GridData.deduplicateSingletonRules(rules) : [];
-            const newGrid = new GridData(arrayOrWidth, height, tiles, connections, zones, newSymbols, newRules);
+            const newGrid = new GridData(arrayOrWidth, height, tiles, connections
+                ? GridConnections.validateEdges(connections, arrayOrWidth, height)
+                : connections, zones ? GridZones.validateEdges(zones, arrayOrWidth, height) : zones, newSymbols, newRules);
             newSymbols.forEach(list => {
                 list.forEach((sym, i) => {
                     if (handlesGridChange(sym)) {

package/dist/data/gridConnections.d.ts

@@ -17,6 +17,7 @@ export default class GridConnections extends GridZones {
      * @returns The created connections. You can apply this to a GridData object using GridData.withConnections.
      */
     static create(array: string[]): GridConnections;
+    static validateEdges(connections: GridConnections, width: number, height: number): GridConnections;
     insertColumn(index: number): GridConnections;
     insertRow(index: number): GridConnections;
     removeColumn(index: number): GridConnections;

package/dist/data/gridConnections.js

@@ -111,6 +111,25 @@ export default class GridConnections extends GridZones {
         }
         return new GridConnections(edges);
     }
+    static validateEdges(connections, width, height) {
+        const newEdges = [];
+        for (const edge of connections.edges) {
+            if (edge.x1 < 0 || edge.x1 >= width || edge.y1 < 0 || edge.y1 >= height) {
+                continue;
+            }
+            if (edge.x2 < 0 || edge.x2 >= width || edge.y2 < 0 || edge.y2 >= height) {
+                continue;
+            }
+            if (Math.abs(edge.x1 - edge.x2) + Math.abs(edge.y1 - edge.y2) !== 1) {
+                continue;
+            }
+            newEdges.push(edge);
+        }
+        if (newEdges.length === connections.edges.length) {
+            return connections;
+        }
+        return new GridConnections(newEdges);
+    }
     insertColumn(index) {
         return new GridConnections(this.edges.flatMap(edge => {
             if ((edge.x1 < index && edge.x2 < index) ||

package/dist/data/gridZones.d.ts

@@ -18,6 +18,7 @@ export default class GridZones {
      * @returns The deduplicated array of edges.
      */
     static deduplicateEdges(edges: readonly Edge[]): readonly Edge[];
+    static validateEdges(connections: GridZones, width: number, height: number): GridZones;
     insertColumn(index: number): GridZones;
     insertRow(index: number): GridZones;
     removeColumn(index: number): GridZones;

package/dist/data/gridZones.js

@@ -48,6 +48,31 @@ export default class GridZones {
     static deduplicateEdges(edges) {
         return edges.filter((edge, index) => edges.findIndex(e => isSameEdge(e, edge)) === index);
     }
+    static validateEdges(connections, width, height) {
+        const newEdges = [];
+        for (const edge of connections.edges) {
+            if (edge.x1 < -1 ||
+                edge.x1 >= width + 1 ||
+                edge.y1 < -1 ||
+                edge.y1 >= height + 1) {
+                continue;
+            }
+            if (edge.x2 < -1 ||
+                edge.x2 >= width + 1 ||
+                edge.y2 < -1 ||
+                edge.y2 >= height + 1) {
+                continue;
+            }
+            if (Math.abs(edge.x1 - edge.x2) + Math.abs(edge.y1 - edge.y2) !== 1) {
+                continue;
+            }
+            newEdges.push(edge);
+        }
+        if (newEdges.length === connections.edges.length) {
+            return connections;
+        }
+        return new GridZones(newEdges);
+    }
     insertColumn(index) {
         return new GridZones(this.edges.map(edge => {
             if (edge.x1 < index || edge.x2 < index) {

package/dist/data/rules/banPatternRule.js

@@ -2,7 +2,7 @@ import { ConfigType } from '../config.js';
 import GridData from '../grid.js';
 import { array } from '../dataHelper.js';
 import { Color, State } from '../primitives.js';
-import { getShapeVariants, tilesToShape } from '../shapes.js';
+import { getShapeVariants, sanitizePatternGrid, tilesToShape, } from '../shapes.js';
 import Rule from './rule.js';
 class BanPatternRule extends Rule {
     /**
@@ -24,14 +24,7 @@ class BanPatternRule extends Rule {
             writable: true,
             value: void 0
         });
-        this.pattern = pattern
-            // unlock all tiles
-            .withTiles(tiles => tiles.map(row => row.map(t => t.exists
-            ? t.withFixed(false)
-            : t.copyWith({ exists: true, color: Color.Gray, fixed: false }))))
-            // strip all symbols and rules
-            .withRules([])
-            .withSymbols(new Map());
+        this.pattern = sanitizePatternGrid(pattern);
         this.cache = getShapeVariants(tilesToShape(this.pattern.tiles));
     }
     get id() {

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

@@ -0,0 +1,33 @@
+import { AnyConfig } from '../config.js';
+import GridData from '../grid.js';
+import { Color, RuleState } from '../primitives.js';
+import { Shape } from '../shapes.js';
+import RegionShapeRule from './regionShapeRule.js';
+import { SearchVariant } from './rule.js';
+export default class ContainsShapeRule extends RegionShapeRule {
+    private static readonly EXAMPLE_GRID_LIGHT;
+    private static readonly EXAMPLE_GRID_DARK;
+    private static readonly CONFIGS;
+    private static readonly SEARCH_VARIANTS;
+    readonly pattern: GridData;
+    readonly cache: Shape[];
+    /**
+     * **All <color> areas must contain this pattern**
+     *
+     * @param color - The color of the regions to compare.
+     * @param pattern - GridData representing the required pattern. Only non-gray tiles are considered.
+     */
+    constructor(color: Color, pattern: GridData);
+    get id(): string;
+    get explanation(): string;
+    get configs(): readonly AnyConfig[] | null;
+    createExampleGrid(): GridData;
+    get searchVariants(): SearchVariant[];
+    validateGrid(grid: GridData): RuleState;
+    copyWith({ color, pattern, }: {
+        color?: Color;
+        pattern?: GridData;
+    }): this;
+    withPattern(pattern: GridData): this;
+}
+export declare const instance: ContainsShapeRule;

package/dist/data/rules/containsShapeRule.js

@@ -0,0 +1,151 @@
+import { ConfigType } from '../config.js';
+import { array } from '../dataHelper.js';
+import GridData from '../grid.js';
+import { Color, State } from '../primitives.js';
+import { getShapeVariants, sanitizePatternGrid, tilesToShape, } from '../shapes.js';
+import RegionShapeRule from './regionShapeRule.js';
+class ContainsShapeRule extends RegionShapeRule {
+    /**
+     * **All <color> areas must contain this pattern**
+     *
+     * @param color - The color of the regions to compare.
+     * @param pattern - GridData representing the required pattern. Only non-gray tiles are considered.
+     */
+    constructor(color, pattern) {
+        super(color);
+        Object.defineProperty(this, "pattern", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "cache", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.pattern = sanitizePatternGrid(pattern, t => t.color === color ? t : t.withColor(Color.Gray));
+        this.cache = getShapeVariants(tilesToShape(this.pattern.tiles));
+    }
+    get id() {
+        return `contains_shape`;
+    }
+    get explanation() {
+        return `All ${this.color} areas must contain this pattern`;
+    }
+    get configs() {
+        return ContainsShapeRule.CONFIGS;
+    }
+    createExampleGrid() {
+        let minX = Number.POSITIVE_INFINITY;
+        let minY = Number.POSITIVE_INFINITY;
+        let maxX = Number.NEGATIVE_INFINITY;
+        let maxY = Number.NEGATIVE_INFINITY;
+        this.pattern.forEach((tile, x, y) => {
+            if (tile.color !== Color.Gray && tile.exists) {
+                minX = Math.min(minX, x);
+                minY = Math.min(minY, y);
+                maxX = Math.max(maxX, x);
+                maxY = Math.max(maxY, y);
+            }
+        });
+        const width = maxX - minX + 1;
+        const height = maxY - minY + 1;
+        const tiles = array(width, height, (x, y) => {
+            const tile = this.pattern.getTile(x + minX, y + minY);
+            if (!tile.exists || tile.color !== Color.Gray)
+                return tile;
+            return tile.withExists(false);
+        });
+        return GridData.create(width, height, tiles);
+    }
+    get searchVariants() {
+        return ContainsShapeRule.SEARCH_VARIANTS;
+    }
+    validateGrid(grid) {
+        const { regions, complete } = this.getShapeRegions(grid);
+        const errorRegion = regions.find(r => {
+            for (const pattern of this.cache) {
+                if (r.shape.elements.length < pattern.elements.length)
+                    continue;
+                for (let y = 0; y <= r.shape.height - pattern.height; y++) {
+                    for (let x = 0; x <= r.shape.width - pattern.width; x++) {
+                        let match = true;
+                        for (const element of pattern.elements) {
+                            const tile = r.shape.elements.find(e => e.x === x + element.x && e.y === y + element.y);
+                            if (!tile || tile.color !== element.color) {
+                                match = false;
+                                break;
+                            }
+                        }
+                        if (match)
+                            return false;
+                    }
+                }
+            }
+            return true;
+        });
+        if (errorRegion) {
+            return {
+                state: State.Error,
+                positions: errorRegion.positions,
+            };
+        }
+        else {
+            return { state: complete ? State.Satisfied : State.Incomplete };
+        }
+    }
+    copyWith({ color, pattern, }) {
+        return new ContainsShapeRule(color ?? this.color, pattern ?? this.pattern);
+    }
+    withPattern(pattern) {
+        return this.copyWith({ pattern });
+    }
+}
+Object.defineProperty(ContainsShapeRule, "EXAMPLE_GRID_LIGHT", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: Object.freeze(GridData.create(['nnnnn', 'nnnnn', 'wwwwn', 'nnnnn', 'nnnnn']))
+});
+Object.defineProperty(ContainsShapeRule, "EXAMPLE_GRID_DARK", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: Object.freeze(GridData.create(['nnnnn', 'nnnnn', 'bbbbn', 'nnnnn', 'nnnnn']))
+});
+Object.defineProperty(ContainsShapeRule, "CONFIGS", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: Object.freeze([
+        {
+            type: ConfigType.Color,
+            default: Color.Light,
+            allowGray: false,
+            field: 'color',
+            description: 'Color',
+            configurable: true,
+        },
+        {
+            type: ConfigType.Tile,
+            default: ContainsShapeRule.EXAMPLE_GRID_LIGHT,
+            resizable: true,
+            field: 'pattern',
+            description: 'Pattern',
+            configurable: true,
+        },
+    ])
+});
+Object.defineProperty(ContainsShapeRule, "SEARCH_VARIANTS", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: [
+        new ContainsShapeRule(Color.Light, ContainsShapeRule.EXAMPLE_GRID_LIGHT).searchVariant(),
+        new ContainsShapeRule(Color.Dark, ContainsShapeRule.EXAMPLE_GRID_DARK).searchVariant(),
+    ]
+});
+export default ContainsShapeRule;
+export const instance = new ContainsShapeRule(Color.Dark, GridData.create([]));

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

@@ -3,6 +3,7 @@ export { instance as CellCountPerZoneRule } from './cellCountPerZoneRule.js';
 export { instance as CellCountRule } from './cellCountRule.js';
 export { instance as CompletePatternRule } from './completePatternRule.js';
 export { instance as ConnectAllRule } from './connectAllRule.js';
+export { instance as ContainsShapeRule } from './containsShapeRule.js';
 export { instance as CustomRule } from './customRule.js';
 export { instance as ForesightRule } from './foresightRule.js';
 export { instance as LyingSymbolRule } from './lyingSymbolRule.js';

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

@@ -7,6 +7,7 @@ export { instance as CellCountPerZoneRule } from './cellCountPerZoneRule.js';
 export { instance as CellCountRule } from './cellCountRule.js';
 export { instance as CompletePatternRule } from './completePatternRule.js';
 export { instance as ConnectAllRule } from './connectAllRule.js';
+export { instance as ContainsShapeRule } from './containsShapeRule.js';
 export { instance as CustomRule } from './customRule.js';
 export { instance as ForesightRule } from './foresightRule.js';
 export { instance as LyingSymbolRule } from './lyingSymbolRule.js';

package/dist/data/shapes.d.ts

@@ -1,3 +1,4 @@
+import GridData from './grid.js';
 import { Color, Position } from './primitives.js';
 import TileData from './tile.js';
 export interface ShapeElement {
@@ -15,3 +16,4 @@ export declare function tilesToShape(tiles: readonly (readonly TileData[])[]): S
 export declare function positionsToShape(positions: Position[], color: Color): Shape;
 export declare function getShapeVariants(shape: Shape): Shape[];
 export declare function normalizeShape(shape: Shape): Shape;
+export declare function sanitizePatternGrid(pattern: GridData, tileMapper?: (tile: TileData) => TileData): GridData;

package/dist/data/shapes.js

@@ -115,3 +115,13 @@ export function normalizeShape(shape) {
     const variants = getShapeVariants(shape);
     return variants.reduce((min, variant) => (compareShape(variant, min) < 0 ? variant : min), variants[0]);
 }
+export function sanitizePatternGrid(pattern, tileMapper = t => t) {
+    return (pattern
+        // unlock all tiles
+        .withTiles(tiles => tiles.map(row => row.map(t => tileMapper(t.exists
+        ? t.withFixed(false)
+        : t.copyWith({ exists: true, color: Color.Gray, fixed: false })))))
+        // strip all symbols and rules
+        .withRules([])
+        .withSymbols(new Map()));
+}

package/dist/data/solver/allSolvers.js

@@ -2,10 +2,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';
+import AutoSolver from './auto/autoSolver.js';
 const allSolvers = new Map();
 function register(prototype) {
     allSolvers.set(prototype.id, prototype);
 }
+register(new AutoSolver());
 register(new CspuzSolver());
 register(new BacktrackSolver());
 register(new UniversalSolver());

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

@@ -0,0 +1,17 @@
+import GridData from '../../grid.js';
+import Solver from '../solver.js';
+export default class AutoSolver extends Solver {
+    readonly id = "auto";
+    readonly author = "various contributors";
+    readonly description = "Automatically select the fastest solver based on supported instructions and environment.";
+    readonly supportsCancellation = true;
+    private static readonly nonAdditiveInstructions;
+    isGridSupported(grid: GridData): boolean;
+    isInstructionSupported(instructionId: string): boolean;
+    protected isEnvironmentSupported(): Promise<boolean>;
+    private fillSolution;
+    private fixGrid;
+    private solveWithProgress;
+    private solveOne;
+    solve(grid: GridData, abortSignal?: AbortSignal | undefined): AsyncGenerator<GridData | null>;
+}

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

@@ -0,0 +1,181 @@
+import { Color, State } from '../../primitives.js';
+import { instance as lyingSymbolInstance } from '../../rules/lyingSymbolRule.js';
+import { instance as offByXInstance } from '../../rules/offByXRule.js';
+import { instance as lotusInstance } from '../../symbols/lotusSymbol.js';
+import { instance as galaxyInstance } from '../../symbols/galaxySymbol.js';
+import { allSolvers } from '../allSolvers.js';
+import Solver from '../solver.js';
+import UndercluedRule from '../../rules/undercluedRule.js';
+import validateGrid from '../../validate.js';
+class AutoSolver extends Solver {
+    constructor() {
+        super(...arguments);
+        Object.defineProperty(this, "id", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 'auto'
+        });
+        Object.defineProperty(this, "author", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 'various contributors'
+        });
+        Object.defineProperty(this, "description", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 'Automatically select the fastest solver based on supported instructions and environment.'
+        });
+        Object.defineProperty(this, "supportsCancellation", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: true
+        });
+    }
+    isGridSupported(grid) {
+        for (const solver of allSolvers.values()) {
+            if (solver.id === this.id)
+                continue;
+            if (solver.isGridSupported(grid)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    isInstructionSupported(instructionId) {
+        for (const solver of allSolvers.values()) {
+            if (solver.id === this.id)
+                continue;
+            if (solver.isInstructionSupported(instructionId)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    async isEnvironmentSupported() {
+        for (const solver of allSolvers.values()) {
+            if (solver.id === this.id)
+                continue;
+            if (await solver.environmentCheck.value) {
+                return true;
+            }
+        }
+        return false;
+    }
+    fillSolution(grid, solution) {
+        return grid.withTiles(tiles => {
+            return tiles.map((row, y) => row.map((tile, x) => {
+                if (!tile.exists || tile.fixed)
+                    return tile;
+                const solutionTile = solution.tiles[y][x];
+                return tile.withColor(solutionTile.color);
+            }));
+        });
+    }
+    fixGrid(grid) {
+        return grid.withTiles(tiles => {
+            return tiles.map(row => row.map(tile => {
+                if (tile.fixed)
+                    return tile;
+                return tile.withFixed(tile.color !== Color.Gray);
+            }));
+        });
+    }
+    async *solveWithProgress(solver, grid, progress, abortSignal) {
+        for await (const updatedGrid of solver.solve(progress, abortSignal)) {
+            if (abortSignal?.aborted)
+                return;
+            if (!updatedGrid)
+                return updatedGrid;
+            yield this.fillSolution(grid, updatedGrid);
+        }
+    }
+    async solveOne(generator) {
+        // eslint-disable-next-line no-unreachable-loop
+        for await (const grid of generator) {
+            return grid;
+        }
+        return null;
+    }
+    async *solve(grid, abortSignal) {
+        if (!!grid.findRule(r => AutoSolver.nonAdditiveInstructions.has(r.id)) ||
+            !!grid.findSymbol(s => AutoSolver.nonAdditiveInstructions.has(s.id))) {
+            for (const solver of allSolvers.values()) {
+                if (solver.id === this.id)
+                    continue;
+                if (solver.isGridSupported(grid)) {
+                    yield* solver.solve(grid, abortSignal);
+                    return;
+                }
+            }
+            throw new Error('No solver supports the given grid');
+        }
+        else {
+            let progressGrid = grid;
+            for (const solver of allSolvers.values()) {
+                if (solver.id === this.id)
+                    continue;
+                if (solver.isGridSupported(progressGrid)) {
+                    yield* this.solveWithProgress(solver, grid, progressGrid, abortSignal);
+                    return;
+                }
+                else if (solver.isGridSupported(grid)) {
+                    yield* solver.solve(grid, abortSignal);
+                    return;
+                }
+                else {
+                    let undercluedGrid = progressGrid
+                        .withRules(rules => rules.filter(r => solver.isInstructionSupported(r.id)))
+                        .withSymbols(symbols => {
+                        for (const id of symbols.keys()) {
+                            if (!solver.isInstructionSupported(id))
+                                symbols.delete(id);
+                        }
+                        return symbols;
+                    })
+                        .addRule(new UndercluedRule());
+                    if (!solver.isGridSupported(undercluedGrid)) {
+                        // special case for solvers that support lotus and galaxy symbols but not dual-color placement
+                        undercluedGrid = undercluedGrid.withSymbols(symbols => {
+                            symbols.delete(lotusInstance.id);
+                            symbols.delete(galaxyInstance.id);
+                            return symbols;
+                        });
+                    }
+                    if (!solver.isGridSupported(undercluedGrid))
+                        continue;
+                    const undercluedSolution = await this.solveOne(this.solveWithProgress(solver, progressGrid, undercluedGrid, abortSignal));
+                    if (undercluedSolution === null)
+                        continue;
+                    if (undercluedSolution.getTileCount(true, false, Color.Gray) === 0) {
+                        const result = this.fillSolution(grid, undercluedSolution);
+                        if (validateGrid(result, null).final !== State.Error) {
+                            yield result;
+                            yield null;
+                            return;
+                        }
+                        else {
+                            yield null;
+                            return;
+                        }
+                    }
+                    progressGrid = this.fixGrid(undercluedSolution);
+                }
+            }
+            yield this.fillSolution(grid, progressGrid);
+        }
+    }
+}
+Object.defineProperty(AutoSolver, "nonAdditiveInstructions", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: new Set([
+        offByXInstance.id,
+        lyingSymbolInstance.id,
+    ])
+});
+export default AutoSolver;

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

@@ -4,7 +4,7 @@ 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.";
+    readonly description = "A blazingly fast WebAssembly solver that supports most rules and symbols (including underclued).";
     protected createWorker(): Worker;
     isGridSupported(grid: GridData): boolean;
     isInstructionSupported(instructionId: string): boolean;

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

@@ -36,7 +36,7 @@ class CspuzSolver extends EventIteratingSolver {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: 'A blazingly fast WebAssembly solver that supports most rules and symbols (including underclued). No uniqueness check yet.'
+            value: 'A blazingly fast WebAssembly solver that supports most rules and symbols (including underclued).'
         });
     }
     createWorker() {

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

@@ -14,10 +14,7 @@ function stringToColor(str) {
         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));
+function postSolution(grid, solverResult) {
     if (solverResult === null) {
         postMessage(null);
     }
@@ -40,5 +37,47 @@ onmessage = e => {
             postMessage(Serializer.stringifyGrid(solution));
         }
     }
+}
+onmessage = e => {
+    const grid = Serializer.parseGrid(e.data);
+    const isUnderclued = !!grid.findRule(r => r.id === undercluedInstance.id);
+    const puzzleData = gridToJson(grid);
+    const solverResult = solveLogicPad(puzzleData, isUnderclued);
+    postSolution(grid, solverResult);
+    // Make use of the underclued mode to determine solution uniqueness
+    if (solverResult !== null && !('error' in solverResult) && !isUnderclued) {
+        const undercluedResult = solveLogicPad(puzzleData, true);
+        if (undercluedResult === null) {
+            postMessage(undefined); // Shouldn't happen because underclued grids should always be solvable
+        }
+        else if ('error' in undercluedResult) {
+            throw new Error(undercluedResult.error);
+        }
+        else if (undercluedResult.every((row, y) => row.every((cell, x) => cell !== null || !grid.getTile(x, y).exists))) {
+            postMessage(null);
+        }
+        else {
+            let tweaked = false;
+            for (const [y, row] of undercluedResult.entries()) {
+                for (const [x, color] of row.entries()) {
+                    if (color !== null) {
+                        puzzleData.tiles[y][x].fixed = true;
+                        puzzleData.tiles[y][x].color = color;
+                    }
+                    else if (!tweaked) {
+                        const positions = grid.connections.getConnectedTiles({ x, y });
+                        const newColor = solverResult[y][x] === 'dark' ? 'light' : 'dark';
+                        positions.forEach(({ x: px, y: py }) => {
+                            puzzleData.tiles[py][px].fixed = true;
+                            puzzleData.tiles[py][px].color = newColor;
+                        });
+                        tweaked = true;
+                    }
+                }
+            }
+            const secondResult = solveLogicPad(puzzleData, false);
+            postSolution(grid, secondResult);
+        }
+    }
     postMessage(undefined);
 };

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

@@ -3,5 +3,6 @@ import Solver from './solver.js';
 export default abstract class EventIteratingSolver extends Solver {
     readonly supportsCancellation = true;
     protected abstract createWorker(): Worker;
+    protected isEnvironmentSupported(): Promise<boolean>;
     solve(grid: GridData, abortSignal?: AbortSignal): AsyncGenerator<GridData | null>;
 }

package/dist/data/solver/eventIteratingSolver.js

@@ -11,6 +11,16 @@ export default class EventIteratingSolver extends Solver {
             value: true
         });
     }
+    isEnvironmentSupported() {
+        try {
+            const worker = this.createWorker();
+            worker.terminate();
+            return Promise.resolve(true);
+        }
+        catch (ex) {
+            return Promise.resolve(false);
+        }
+    }
     async *solve(grid, abortSignal) {
         const worker = this.createWorker();
         const terminateHandler = () => worker.terminate();

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

@@ -1,3 +1,4 @@
+import { CachedAccess } from '../dataHelper.js';
 import GridData from '../grid.js';
 /**
  * Base class that all solvers must extend.
@@ -49,7 +50,8 @@ export default abstract class Solver {
      *
      * @returns A promise that resolves to `true` if the environment is supported, or `false` otherwise.
      */
-    isEnvironmentSupported(): Promise<boolean>;
+    protected isEnvironmentSupported(): Promise<boolean>;
+    readonly environmentCheck: CachedAccess<Promise<boolean>>;
     /**
      * Check if the solver supports the given instruction. This is used to render a small indication in the UI for each
      * instruction in the editor.

package/dist/data/solver/solver.js

@@ -1,9 +1,18 @@
+import { CachedAccess } from '../dataHelper.js';
 import { allRules } from '../rules/index.js';
 import { allSymbols } from '../symbols/index.js';
 /**
  * Base class that all solvers must extend.
  */
 export default class Solver {
+    constructor() {
+        Object.defineProperty(this, "environmentCheck", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: CachedAccess.of(() => this.isEnvironmentSupported())
+        });
+    }
     /**
      * Check if the solver supports the current browser environment. This method is called once when the user first clicks
      * the "Solve" button, and the result is cached for the duration of the editor session.

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

@@ -5,7 +5,7 @@ export default class Z3Solver extends Solver {
     readonly author = "Lysine";
     readonly description = "(Obsolete) A WebAssembly solver that supports a limited set of rules and symbols.";
     readonly supportsCancellation = false;
-    isEnvironmentSupported(): Promise<boolean>;
+    protected isEnvironmentSupported(): Promise<boolean>;
     solve(grid: GridData): AsyncGenerator<GridData | null>;
     isInstructionSupported(instructionId: string): boolean;
     isGridSupported(grid: GridData): boolean;

package/dist/index.d.ts

@@ -20,6 +20,7 @@ import CellCountPerZoneRule from './data/rules/cellCountPerZoneRule.js';
 import CellCountRule from './data/rules/cellCountRule.js';
 import CompletePatternRule from './data/rules/completePatternRule.js';
 import ConnectAllRule from './data/rules/connectAllRule.js';
+import ContainsShapeRule from './data/rules/containsShapeRule.js';
 import CustomRule from './data/rules/customRule.js';
 import ForesightRule from './data/rules/foresightRule.js';
 import { allRules } from './data/rules/index.js';
@@ -45,8 +46,9 @@ import GzipCompressor from './data/serializer/compressor/gzipCompressor.js';
 import StreamCompressor from './data/serializer/compressor/streamCompressor.js';
 import SerializerBase from './data/serializer/serializerBase.js';
 import SerializerV0 from './data/serializer/serializer_v0.js';
-import { getShapeVariants, normalizeShape, positionsToShape, shapeEquals, tilesToShape } from './data/shapes.js';
+import { getShapeVariants, normalizeShape, positionsToShape, sanitizePatternGrid, shapeEquals, tilesToShape } from './data/shapes.js';
 import { allSolvers } from './data/solver/allSolvers.js';
+import AutoSolver from './data/solver/auto/autoSolver.js';
 import BacktrackSolver from './data/solver/backtrack/backtrackSolver.js';
 import BTModule, { BTGridData, BTTile, IntArray2D, colorToBTTile, createOneTileResult, getOppositeColor } from './data/solver/backtrack/data.js';
 import BanPatternBTModule from './data/solver/backtrack/rules/banPattern.js';
@@ -106,4 +108,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, 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, };
+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, ContainsShapeRule, 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, sanitizePatternGrid, shapeEquals, tilesToShape, allSolvers, AutoSolver, 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

@@ -23,6 +23,7 @@ import CellCountPerZoneRule from './data/rules/cellCountPerZoneRule.js';
 import CellCountRule from './data/rules/cellCountRule.js';
 import CompletePatternRule from './data/rules/completePatternRule.js';
 import ConnectAllRule from './data/rules/connectAllRule.js';
+import ContainsShapeRule from './data/rules/containsShapeRule.js';
 import CustomRule from './data/rules/customRule.js';
 import ForesightRule from './data/rules/foresightRule.js';
 import { allRules } from './data/rules/index.js';
@@ -48,8 +49,9 @@ import GzipCompressor from './data/serializer/compressor/gzipCompressor.js';
 import StreamCompressor from './data/serializer/compressor/streamCompressor.js';
 import SerializerBase from './data/serializer/serializerBase.js';
 import SerializerV0 from './data/serializer/serializer_v0.js';
-import { getShapeVariants, normalizeShape, positionsToShape, shapeEquals, tilesToShape } from './data/shapes.js';
+import { getShapeVariants, normalizeShape, positionsToShape, sanitizePatternGrid, shapeEquals, tilesToShape } from './data/shapes.js';
 import { allSolvers } from './data/solver/allSolvers.js';
+import AutoSolver from './data/solver/auto/autoSolver.js';
 import BacktrackSolver from './data/solver/backtrack/backtrackSolver.js';
 import BTModule, { BTGridData, BTTile, IntArray2D, colorToBTTile, createOneTileResult, getOppositeColor } from './data/solver/backtrack/data.js';
 import BanPatternBTModule from './data/solver/backtrack/rules/banPattern.js';
@@ -109,4 +111,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, 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, };
+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, ContainsShapeRule, 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, sanitizePatternGrid, shapeEquals, tilesToShape, allSolvers, AutoSolver, 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.10.1",
+  "version": "0.11.0",
   "type": "module",
   "files": [
     "dist",