logic-puzzle-generator 1.0.0 → 1.2.0

package/dist/LogicGrid.js

@@ -1,188 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.LogicGrid = void 0;
-/**
- * Represents the state of the logic puzzle grid.
- *
- * It manages the possibilities between every pair of values across different categories.
- * The grid is initialized where all connections are possible (true).
- * As clues are applied, possibilities are eliminated (set to false).
- */
-class LogicGrid {
-    /**
-     * Creates a new LogicGrid instance.
-     *
-     * @param categories - The configuration of categories and their values for the puzzle.
-     * @throws {Error} If the configuration is invalid (duplicate IDs, duplicate values, or mismatched value counts).
-     */
-    constructor(categories) {
-        this._validateCategories(categories);
-        this.categories = categories;
-        this.valueMap = new Map(categories.map(c => [c.id, new Map(c.values.map((v, i) => [v, i]))]));
-        this.grid = new Map();
-        for (const cat1 of categories) {
-            const cat1Map = new Map();
-            for (const val1 of cat1.values) {
-                const cat2Map = new Map();
-                for (const cat2 of categories) {
-                    if (cat1.id === cat2.id)
-                        continue;
-                    cat2Map.set(cat2.id, Array(cat2.values.length).fill(true));
-                }
-                cat1Map.set(val1, cat2Map);
-            }
-            this.grid.set(cat1.id, cat1Map);
-        }
-    }
-    _validateCategories(categories) {
-        if (categories.length === 0) {
-            return; // Or throw an error, for now we allow it.
-        }
-        const firstCategoryValueCount = categories[0].values.length;
-        const categoryIds = new Set();
-        for (const category of categories) {
-            if (categoryIds.has(category.id)) {
-                throw new Error(`Invalid configuration: Duplicate category ID found: "${category.id}".`);
-            }
-            categoryIds.add(category.id);
-            if (category.values.length !== firstCategoryValueCount) {
-                throw new Error(`Invalid configuration: All categories must have the same number of values. Category "${category.id}" has ${category.values.length} values, but category "${categories[0].id}" has ${firstCategoryValueCount}.`);
-            }
-            const categoryValues = new Set();
-            for (const value of category.values) {
-                if (categoryValues.has(value)) {
-                    throw new Error(`Invalid configuration: Duplicate value "${value}" found in category "${category.id}".`);
-                }
-                categoryValues.add(value);
-            }
-        }
-    }
-    /**
-     * Sets the possibility state between two values from different categories.
-     *
-     * @param cat1Id - The ID of the first category.
-     * @param val1 - The value from the first category.
-     * @param cat2Id - The ID of the second category.
-     * @param val2 - The value from the second category.
-     * @param state - true if the connection is possible, false if eliminated.
-     */
-    setPossibility(cat1Id, val1, cat2Id, val2, state) {
-        const val2Index = this.valueMap.get(cat2Id)?.get(val2);
-        if (val2Index !== undefined) {
-            const cat1Map = this.grid.get(cat1Id);
-            if (cat1Map) {
-                const val1Map = cat1Map.get(val1);
-                if (val1Map) {
-                    const cat2Arr = val1Map.get(cat2Id);
-                    if (cat2Arr) {
-                        cat2Arr[val2Index] = state;
-                    }
-                }
-            }
-        }
-        const val1Index = this.valueMap.get(cat1Id)?.get(val1);
-        if (val1Index !== undefined) {
-            const cat2Map = this.grid.get(cat2Id);
-            if (cat2Map) {
-                const val2Map = cat2Map.get(val2);
-                if (val2Map) {
-                    const cat1Arr = val2Map.get(cat1Id);
-                    if (cat1Arr) {
-                        cat1Arr[val1Index] = state;
-                    }
-                }
-            }
-        }
-    }
-    /**
-     * Checks if a connection between two values is currently possible.
-     *
-     * @param cat1Id - The ID of the first category.
-     * @param val1 - The value from the first category.
-     * @param cat2Id - The ID of the second category.
-     * @param val2 - The value from the second category.
-     * @returns true if the connection is possible, false otherwise.
-     */
-    isPossible(cat1Id, val1, cat2Id, val2) {
-        const val2Index = this.valueMap.get(cat2Id)?.get(val2);
-        if (val2Index === undefined)
-            return false;
-        const cat1Grid = this.grid.get(cat1Id);
-        if (!cat1Grid)
-            return false;
-        const val1Grid = cat1Grid.get(val1);
-        if (!val1Grid)
-            return false;
-        const cat2Arr = val1Grid.get(cat2Id);
-        if (!cat2Arr)
-            return false;
-        return cat2Arr[val2Index];
-    }
-    /**
-     * Gets the number of possible connections for a specific value in one category
-     * relative to another category.
-     *
-     * @param cat1Id - The ID of the starting category.
-     * @param val1 - The value from the starting category.
-     * @param cat2Id - The target category ID.
-     * @returns The number of values in cat2 that are still possible for val1.
-     */
-    getPossibilitiesCount(cat1Id, val1, cat2Id) {
-        const possibilities = this.grid.get(cat1Id)?.get(val1)?.get(cat2Id);
-        if (!possibilities)
-            return 0;
-        return possibilities.filter(p => p).length;
-    }
-    /**
-     * Calculates statistics about the current state of the grid.
-     *
-     * @returns An object containing:
-     *  - totalPossible: The initial total logical connections.
-     *  - currentPossible: The number of remaining possible connections.
-     *  - solutionPossible: The target number of connections for a solved grid.
-     */
-    getGridStats() {
-        let currentPossible = 0;
-        const catCount = this.categories.length;
-        const valCount = this.categories[0]?.values.length || 0;
-        if (valCount === 0 || catCount < 2) {
-            return { totalPossible: 0, currentPossible: 0, solutionPossible: 0 };
-        }
-        const numPairs = catCount * (catCount - 1) / 2;
-        const totalPossible = numPairs * valCount * valCount;
-        const solutionPossible = numPairs * valCount;
-        for (const cat1 of this.categories) {
-            for (const val1 of cat1.values) {
-                for (const cat2 of this.categories) {
-                    if (cat1.id >= cat2.id)
-                        continue;
-                    const possibilities = this.grid.get(cat1.id)?.get(val1)?.get(cat2.id);
-                    if (possibilities) {
-                        currentPossible += possibilities.filter(p => p).length;
-                    }
-                }
-            }
-        }
-        return { totalPossible, currentPossible, solutionPossible };
-    }
-    /**
-     * Creates a deep copy of the current LogicGrid.
-     *
-     * @returns A new LogicGrid instance with the exact same state.
-     */
-    clone() {
-        const newGrid = new LogicGrid(this.categories);
-        newGrid.grid = new Map([...this.grid.entries()].map(([cat1Id, cat1Map]) => [
-            cat1Id,
-            new Map([...cat1Map.entries()].map(([val1, val1Map]) => [
-                val1,
-                new Map([...val1Map.entries()].map(([cat2Id, cat2Arr]) => [
-                    cat2Id,
-                    [...cat2Arr],
-                ])),
-            ])),
-        ]));
-        return newGrid;
-    }
-}
-exports.LogicGrid = LogicGrid;

package/dist/Solver.d.ts

@@ -1,29 +0,0 @@
-import { LogicGrid } from './LogicGrid';
-import { Clue } from './Clue';
-/**
- * The logical engine responsible for applying clues to a LogicGrid and deducing consequences.
- *
- * It implements various deduction strategies including basic elimination, uniqueness checks,
- * and transitive logic logic (if A=B and B=C, then A=C).
- */
-export declare class Solver {
-    /**
-     * Applies a single clue to the grid and propagates logical deductions.
-     *
-     * This method runs a loop that explicitly applies the clue and then repeatedly
-     * triggers the internal deduction engine until no further eliminations can be made.
-     *
-     * @param grid - The LogicGrid to modify.
-     * @param clue - The Clue to apply.
-     * @returns An object containing the modified grid and the total count of eliminations made.
-     */
-    applyClue(grid: LogicGrid, clue: Clue): {
-        grid: LogicGrid;
-        deductions: number;
-    };
-    private applyUnaryClue;
-    private applyBinaryClue;
-    private runDeductionLoop;
-    private applyOrdinalClue;
-    private applySuperlativeClue;
-}

package/dist/Solver.js

@@ -1,242 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Solver = void 0;
-const Clue_1 = require("./Clue");
-const types_1 = require("./types");
-/**
- * The logical engine responsible for applying clues to a LogicGrid and deducing consequences.
- *
- * It implements various deduction strategies including basic elimination, uniqueness checks,
- * and transitive logic logic (if A=B and B=C, then A=C).
- */
-class Solver {
-    /**
-     * Applies a single clue to the grid and propagates logical deductions.
-     *
-     * This method runs a loop that explicitly applies the clue and then repeatedly
-     * triggers the internal deduction engine until no further eliminations can be made.
-     *
-     * @param grid - The LogicGrid to modify.
-     * @param clue - The Clue to apply.
-     * @returns An object containing the modified grid and the total count of eliminations made.
-     */
-    applyClue(grid, clue) {
-        let deductions = 0;
-        switch (clue.type) {
-            case Clue_1.ClueType.BINARY:
-                deductions += this.applyBinaryClue(grid, clue);
-                break;
-            case Clue_1.ClueType.SUPERLATIVE:
-                deductions += this.applySuperlativeClue(grid, clue);
-                break;
-            case Clue_1.ClueType.ORDINAL:
-                deductions += this.applyOrdinalClue(grid, clue);
-                break;
-            case Clue_1.ClueType.UNARY:
-                deductions += this.applyUnaryClue(grid, clue);
-                break;
-        }
-        let newDeductions;
-        do {
-            newDeductions = this.runDeductionLoop(grid);
-            deductions += newDeductions;
-        } while (newDeductions > 0);
-        return { grid, deductions };
-    }
-    applyUnaryClue(grid, clue) {
-        let deductions = 0;
-        const categories = grid.categories;
-        const ordinalCatConfig = categories.find(c => c.id === clue.ordinalCat);
-        if (!ordinalCatConfig || ordinalCatConfig.type !== types_1.CategoryType.ORDINAL)
-            return 0;
-        if (!ordinalCatConfig.values.every(v => typeof v === 'number'))
-            return 0;
-        const isEven = clue.filter === Clue_1.UnaryFilter.IS_EVEN;
-        for (const ordVal of ordinalCatConfig.values) {
-            const ordNum = ordVal;
-            const shouldEliminate = isEven ? ordNum % 2 !== 0 : ordNum % 2 === 0;
-            if (shouldEliminate) {
-                if (grid.isPossible(clue.targetCat, clue.targetVal, clue.ordinalCat, ordVal)) {
-                    grid.setPossibility(clue.targetCat, clue.targetVal, clue.ordinalCat, ordVal, false);
-                    deductions++;
-                }
-            }
-        }
-        return deductions;
-    }
-    applyBinaryClue(grid, clue) {
-        let deductions = 0;
-        const categories = grid.categories;
-        const cat1Config = categories.find(c => c.id === clue.cat1);
-        const cat2Config = categories.find(c => c.id === clue.cat2);
-        if (!cat1Config || !cat2Config)
-            return 0;
-        if (clue.operator === Clue_1.BinaryOperator.IS) {
-            if (grid.isPossible(clue.cat1, clue.val1, clue.cat2, clue.val2)) {
-                // This is not a deduction, but a fact application. Still, we need to eliminate other possibilities.
-            }
-            grid.setPossibility(clue.cat1, clue.val1, clue.cat2, clue.val2, true);
-            for (const val of cat2Config.values) {
-                if (val !== clue.val2) {
-                    if (grid.isPossible(clue.cat1, clue.val1, clue.cat2, val)) {
-                        grid.setPossibility(clue.cat1, clue.val1, clue.cat2, val, false);
-                        deductions++;
-                    }
-                }
-            }
-            for (const val of cat1Config.values) {
-                if (val !== clue.val1) {
-                    if (grid.isPossible(clue.cat1, val, clue.cat2, clue.val2)) {
-                        grid.setPossibility(clue.cat1, val, clue.cat2, clue.val2, false);
-                        deductions++;
-                    }
-                }
-            }
-        }
-        else { // IS_NOT
-            if (grid.isPossible(clue.cat1, clue.val1, clue.cat2, clue.val2)) {
-                grid.setPossibility(clue.cat1, clue.val1, clue.cat2, clue.val2, false);
-                deductions++;
-            }
-        }
-        return deductions;
-    }
-    runDeductionLoop(grid) {
-        let deductions = 0;
-        const categories = grid.categories;
-        for (const cat1 of categories) {
-            for (const val1 of cat1.values) {
-                for (const cat2 of categories) {
-                    if (cat1.id === cat2.id)
-                        continue;
-                    // Uniqueness Check
-                    const possibleValues = cat2.values.filter(val2 => grid.isPossible(cat1.id, val1, cat2.id, val2));
-                    if (possibleValues.length === 1) {
-                        const val2 = possibleValues[0];
-                        // If val1 is uniquely associated with val2, then no other val from cat1 can be associated with val2
-                        for (const otherVal1 of cat1.values) {
-                            if (otherVal1 !== val1) {
-                                if (grid.isPossible(cat1.id, otherVal1, cat2.id, val2)) {
-                                    grid.setPossibility(cat1.id, otherVal1, cat2.id, val2, false);
-                                    deductions++;
-                                }
-                            }
-                        }
-                    }
-                    // Transitivity
-                    for (const cat3 of categories) {
-                        if (cat1.id === cat3.id || cat2.id === cat3.id)
-                            continue;
-                        // Positive Transitivity
-                        const definiteVal2 = possibleValues.length === 1 ? possibleValues[0] : null;
-                        if (definiteVal2) {
-                            const possibleVal3s = cat3.values.filter(val3 => grid.isPossible(cat2.id, definiteVal2, cat3.id, val3));
-                            if (possibleVal3s.length === 1) {
-                                const definiteVal3 = possibleVal3s[0];
-                                if (grid.isPossible(cat1.id, val1, cat3.id, definiteVal3) === false) {
-                                    // This indicates a contradiction, but for now we are just making deductions.
-                                }
-                                else if (grid.getPossibilitiesCount(cat1.id, val1, cat3.id) > 1) {
-                                    grid.setPossibility(cat1.id, val1, cat3.id, definiteVal3, true);
-                                    deductions++;
-                                }
-                            }
-                        }
-                        // Negative Transitivity
-                        for (const val3 of cat3.values) {
-                            if (grid.isPossible(cat1.id, val1, cat3.id, val3)) {
-                                const isPathPossible = cat2.values.some(val2 => grid.isPossible(cat1.id, val1, cat2.id, val2) && grid.isPossible(cat2.id, val2, cat3.id, val3));
-                                if (!isPathPossible) {
-                                    grid.setPossibility(cat1.id, val1, cat3.id, val3, false);
-                                    deductions++;
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-        }
-        return deductions;
-    }
-    applyOrdinalClue(grid, constraint) {
-        let deductions = 0;
-        const categories = grid.categories;
-        const ordCatConfig = categories.find(c => c.id === constraint.ordinalCat);
-        if (!ordCatConfig || ordCatConfig.type !== types_1.CategoryType.ORDINAL)
-            return 0;
-        const possibleVals1 = ordCatConfig.values
-            .map((v, i) => ({ val: v, idx: i }))
-            .filter(v => grid.isPossible(constraint.item1Cat, constraint.item1Val, constraint.ordinalCat, v.val));
-        const possibleVals2 = ordCatConfig.values
-            .map((v, i) => ({ val: v, idx: i }))
-            .filter(v => grid.isPossible(constraint.item2Cat, constraint.item2Val, constraint.ordinalCat, v.val));
-        if (possibleVals1.length === 0 || possibleVals2.length === 0)
-            return 0;
-        if (constraint.operator === Clue_1.OrdinalOperator.GREATER_THAN) { // item1 > item2
-            // Prune item1's possibilities
-            for (const pval1 of possibleVals1) {
-                const canBeGreaterThan = possibleVals2.some(pval2 => pval1.idx > pval2.idx);
-                if (!canBeGreaterThan) {
-                    if (grid.isPossible(constraint.item1Cat, constraint.item1Val, constraint.ordinalCat, pval1.val)) {
-                        grid.setPossibility(constraint.item1Cat, constraint.item1Val, constraint.ordinalCat, pval1.val, false);
-                        deductions++;
-                    }
-                }
-            }
-            // Prune item2's possibilities
-            for (const pval2 of possibleVals2) {
-                const canBeLessThan = possibleVals1.some(pval1 => pval1.idx > pval2.idx);
-                if (!canBeLessThan) {
-                    if (grid.isPossible(constraint.item2Cat, constraint.item2Val, constraint.ordinalCat, pval2.val)) {
-                        grid.setPossibility(constraint.item2Cat, constraint.item2Val, constraint.ordinalCat, pval2.val, false);
-                        deductions++;
-                    }
-                }
-            }
-        }
-        else if (constraint.operator === Clue_1.OrdinalOperator.LESS_THAN) { // item1 < item2
-            // Prune item1's possibilities
-            for (const pval1 of possibleVals1) {
-                const canBeLessThan = possibleVals2.some(pval2 => pval1.idx < pval2.idx);
-                if (!canBeLessThan) {
-                    if (grid.isPossible(constraint.item1Cat, constraint.item1Val, constraint.ordinalCat, pval1.val)) {
-                        grid.setPossibility(constraint.item1Cat, constraint.item1Val, constraint.ordinalCat, pval1.val, false);
-                        deductions++;
-                    }
-                }
-            }
-            // Prune item2's possibilities
-            for (const pval2 of possibleVals2) {
-                const canBeGreaterThan = possibleVals1.some(pval1 => pval1.idx < pval2.idx);
-                if (!canBeGreaterThan) {
-                    if (grid.isPossible(constraint.item2Cat, constraint.item2Val, constraint.ordinalCat, pval2.val)) {
-                        grid.setPossibility(constraint.item2Cat, constraint.item2Val, constraint.ordinalCat, pval2.val, false);
-                        deductions++;
-                    }
-                }
-            }
-        }
-        return deductions;
-    }
-    applySuperlativeClue(grid, clue) {
-        const categories = grid.categories;
-        const ordinalCatConfig = categories.find(c => c.id === clue.ordinalCat);
-        if (!ordinalCatConfig || ordinalCatConfig.type !== types_1.CategoryType.ORDINAL)
-            return 0;
-        // Assuming values are sorted in ascending order for ordinal categories
-        const extremeValue = clue.operator === Clue_1.SuperlativeOperator.MAX
-            ? ordinalCatConfig.values[ordinalCatConfig.values.length - 1]
-            : ordinalCatConfig.values[0];
-        // This clue is essentially a binary IS clue.
-        const binaryClue = {
-            type: Clue_1.ClueType.BINARY,
-            cat1: clue.targetCat,
-            val1: clue.targetVal,
-            cat2: clue.ordinalCat,
-            val2: extremeValue,
-            operator: Clue_1.BinaryOperator.IS,
-        };
-        return this.applyBinaryClue(grid, binaryClue);
-    }
-}
-exports.Solver = Solver;

package/dist/index.d.ts

@@ -1,5 +0,0 @@
-export * from './types';
-export * from './Clue';
-export * from './LogicGrid';
-export * from './Solver';
-export * from './Generator';

package/dist/index.js

@@ -1,21 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./types"), exports);
-__exportStar(require("./Clue"), exports);
-__exportStar(require("./LogicGrid"), exports);
-__exportStar(require("./Solver"), exports);
-__exportStar(require("./Generator"), exports);

package/dist/run_generator.d.ts

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

package/dist/run_generator.js

@@ -1,84 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const types_1 = require("./types");
-const Generator_1 = require("./Generator");
-const Solver_1 = require("./Solver");
-const LogicGrid_1 = require("./LogicGrid");
-const Clue_1 = require("./Clue");
-const categories = [
-    { id: 'Name', type: types_1.CategoryType.NOMINAL, values: ['Alice', 'Bob', 'Charlie', 'David'] },
-    { id: 'Genre', type: types_1.CategoryType.NOMINAL, values: ['Horror', 'Sci-Fi', 'Comedy', 'Drama'] },
-    { id: 'Snack', type: types_1.CategoryType.NOMINAL, values: ['Chips', 'Popcorn', 'Candy', 'Chocolate'] },
-    { id: 'Age', type: types_1.CategoryType.ORDINAL, values: [20, 30, 40, 50] },
-];
-const targetFact = {
-    category1Id: 'Name',
-    value1: 'David',
-    category2Id: 'Snack',
-};
-const seed = 1234;
-const generator = new Generator_1.Generator(seed);
-const puzzle = generator.generatePuzzle(categories, targetFact);
-console.log(`## ✨ Generated Puzzle (Seed: ${seed})`);
-console.log('\n---\n');
-console.log('### The Answer Key (For Verification Only)');
-const baseCat = puzzle.categories[0];
-for (const val of baseCat.values) {
-    let line = '';
-    for (const cat of puzzle.categories) {
-        line += `${cat.id}: ${puzzle.solution[cat.id][val]} | `;
-    }
-    console.log(line.slice(0, -3));
-}
-console.log('\n### Goal');
-console.log(`What ${puzzle.targetFact.category2Id} does [Name: ${puzzle.targetFact.value1}] have?`);
-console.log('\n---\n');
-console.log('### 🧩 Clue-by-Clue Proof Chain\n');
-// The new API provides the proof chain directly, so we don't need to re-run the solver.
-// We still create a grid to show the ambiguity snapshot at each step.
-const logicGrid = new LogicGrid_1.LogicGrid(categories);
-const solver = new Solver_1.Solver();
-puzzle.proofChain.forEach((step, index) => {
-    console.log(`STEP ${index + 1}: Clue: ${clueToString(step.clue)}`);
-    console.log(`Deductions: ${step.deductions} eliminations made.`);
-    // Apply the clue to our local grid to show the state *after* this clue is applied
-    solver.applyClue(logicGrid, step.clue);
-    console.log('\nAmbiguity Snapshot:');
-    // Focused snapshot for the target fact
-    const targetCat2 = categories.find(c => c.id === puzzle.targetFact.category2Id);
-    if (targetCat2) {
-        const possibleValues = targetCat2.values.filter(v => logicGrid.isPossible(puzzle.targetFact.category1Id, puzzle.targetFact.value1, puzzle.targetFact.category2Id, v));
-        console.log(`- Target: [${puzzle.targetFact.category1Id}: ${puzzle.targetFact.value1}] vs [${puzzle.targetFact.category2Id}]: ${possibleValues.length} possibilities remain -> [${possibleValues.join(', ')}]`);
-    }
-    // Overall grid completion
-    const { totalPossible, currentPossible, solutionPossible } = logicGrid.getGridStats();
-    const totalEliminatable = totalPossible - solutionPossible;
-    const eliminatedSoFar = totalPossible - currentPossible;
-    const percentageSolved = totalEliminatable > 0 ? (eliminatedSoFar / totalEliminatable) * 100 : 0;
-    console.log(`- Grid Solved: ${percentageSolved.toFixed(1)}%`);
-    console.log('\n---\n');
-});
-const targetValue = puzzle.solution[puzzle.targetFact.category2Id][puzzle.targetFact.value1];
-console.log(`\n**Target Fact Solved:** [${puzzle.targetFact.category1Id}: ${puzzle.targetFact.value1}] is correlated with [${puzzle.targetFact.category2Id}: ${targetValue}]!`);
-function clueToString(clue) {
-    switch (clue.type) {
-        case Clue_1.ClueType.BINARY:
-            const b = clue;
-            const op = b.operator === Clue_1.BinaryOperator.IS ? 'is' : 'is not';
-            return `[${b.cat1}: ${b.val1}] ${op} [${b.cat2}: ${b.val2}]`;
-        case Clue_1.ClueType.ORDINAL:
-            const o = clue;
-            const ordOp = o.operator === Clue_1.OrdinalOperator.GREATER_THAN ? 'is greater than' : 'is less than';
-            return `The one with [${o.item1Cat}: ${o.item1Val}] ${ordOp} the one with [${o.item2Cat}: ${o.item2Val}] (by ${o.ordinalCat})`;
-        case Clue_1.ClueType.SUPERLATIVE:
-            const s = clue;
-            const supOp = s.operator === Clue_1.SuperlativeOperator.MAX ? 'is the oldest' : 'is the youngest';
-            return `[${s.targetCat}: ${s.targetVal}] ${supOp}`;
-        case Clue_1.ClueType.UNARY:
-            const u = clue;
-            const filterStr = u.filter === Clue_1.UnaryFilter.IS_EVEN ? 'even' : 'odd';
-            return `[${u.targetCat}: ${u.targetVal}] is associated with an ${filterStr} ${u.ordinalCat}`;
-        default:
-            return 'Unknown Clue Type';
-    }
-}

package/dist/types.d.ts

@@ -1,37 +0,0 @@
-/**
- * A primitive value that acts as a label for an entity (e.g., "Alice", 42).
- */
-export type ValueLabel = string | number;
-/**
- * Defines the nature of a category's values.
- */
-export declare enum CategoryType {
-    /** Order is irrelevant (e.g., Name, Genre). */
-    NOMINAL = 0,
-    /** Order is crucial for comparisons (e.g., Age, Price). Values must be numbers. */
-    ORDINAL = 1
-}
-/**
- * Configuration for a single category in the puzzle.
- */
-export interface CategoryConfig {
-    /** Unique internal identifier for the category (e.g., 'Name'). */
-    id: string;
-    /** The type of data this category holds. */
-    type: CategoryType;
-    /** The list of possible values. Must be unique. If ORDINAL, they must be sorted. */
-    values: ValueLabel[];
-}
-/**
- * Represents the complete solution to the puzzle (the "answer key").
- * Structure: { CategoryID -> { Value -> CorrectValueInOtherCategory } }
- */
-export type Solution = Record<string, Record<string, ValueLabel>>;
-/**
- * A specific correlation that the puzzle solver aims to deduce as the final answer.
- */
-export interface TargetFact {
-    category1Id: string;
-    value1: ValueLabel;
-    category2Id: string;
-}

package/dist/types.js

@@ -1,13 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CategoryType = void 0;
-/**
- * Defines the nature of a category's values.
- */
-var CategoryType;
-(function (CategoryType) {
-    /** Order is irrelevant (e.g., Name, Genre). */
-    CategoryType[CategoryType["NOMINAL"] = 0] = "NOMINAL";
-    /** Order is crucial for comparisons (e.g., Age, Price). Values must be numbers. */
-    CategoryType[CategoryType["ORDINAL"] = 1] = "ORDINAL";
-})(CategoryType || (exports.CategoryType = CategoryType = {}));