@sudobility/sudojo_types 1.2.36 → 1.2.37

package/README.md

@@ -0,0 +1,46 @@
+# @sudobility/sudojo_types
+
+Shared TypeScript type definitions for the Sudojo Sudoku learning platform.
+
+## Installation
+
+```bash
+bun add @sudobility/sudojo_types
+```
+
+## Usage
+
+```typescript
+import type { Board, Daily, Level, Technique, TechniqueId } from '@sudobility/sudojo_types';
+import { successResponse, errorResponse } from '@sudobility/sudojo_types';
+import { techniqueToBit, hasTechnique, addTechnique } from '@sudobility/sudojo_types';
+```
+
+## Types
+
+- **Entities**: `Board`, `Daily`, `Level`, `Technique`, `UserProgress`, `Challenge`
+- **Enums**: `TechniqueId` (60 solving techniques)
+- **Requests/Responses**: Create/update types for boards, dailies, levels, techniques
+- **Utilities**: `ApiResponse<T>`, `PaginatedResponse<T>`, `successResponse()`, `errorResponse()` (re-exported from `@sudobility/types`)
+- **BigInt helpers**: `techniqueToBit()`, `hasTechnique()`, `addTechnique()` for technique bitmask fields
+
+## Development
+
+```bash
+bun run build        # Build ESM + CJS
+bun run test         # Run tests once
+bun run typecheck    # TypeScript check
+bun run lint         # ESLint
+bun run verify       # Typecheck + lint + test + build
+```
+
+## Related Packages
+
+- `@sudobility/sudojo_client` -- React Query hooks for Sudojo API
+- `@sudobility/sudojo_lib` -- Business logic and game state hooks
+- `sudojo_api` -- Backend API server
+- `sudojo_app` / `sudojo_app_rn` -- Web and mobile apps
+
+## License
+
+BUSL-1.1

package/package.json

@@ -1,22 +1,18 @@
 {
   "name": "@sudobility/sudojo_types",
-  "version": "1.2.36",
+  "version": "1.2.37",
   "description": "TypeScript types for Sudojo API - Sudoku learning platform",
-  "main": "./dist/index.cjs",
-  "module": "./dist/index.js",
+  "type": "module",
+  "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "exports": {
     ".": {
       "import": "./dist/index.js",
-      "require": "./dist/index.cjs",
       "types": "./dist/index.d.ts"
     }
   },
   "scripts": {
-    "build": "bun run build:cjs && bun run build:esm",
-    "build:esm": "tsc -p tsconfig.esm.json",
-    "build:cjs": "tsc -p tsconfig.cjs.json && bun run build:cjs-rename",
-    "build:cjs-rename": "for f in dist/*.js; do mv \"$f\" \"${f%.js}.cjs\"; done",
+    "build": "tsc -p tsconfig.esm.json",
     "clean": "rimraf dist",
     "dev": "tsc --watch",
     "test": "vitest run",
@@ -44,11 +40,11 @@
   "author": "Sudobility",
   "license": "BUSL-1.1",
   "peerDependencies": {
-    "@sudobility/types": "^1.9.55"
+    "@sudobility/types": "^1.9.57"
   },
   "devDependencies": {
     "@eslint/js": "^9.38.0",
-    "@sudobility/types": "^1.9.55",
+    "@sudobility/types": "^1.9.57",
     "@typescript-eslint/eslint-plugin": "^8.46.2",
     "@typescript-eslint/parser": "^8.46.2",
     "eslint": "^9.38.0",

package/dist/index.cjs

@@ -1,1080 +0,0 @@
-"use strict";
-/**
- * @sudobility/sudojo-types
- * TypeScript types for Sudojo API - Sudoku learning platform
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EMPTY_PENCILMARKS = exports.EMPTY_BOARD = exports.DEFAULT_SCRAMBLE_CONFIG = exports.TOTAL_CELLS = exports.BLOCK_SIZE = exports.BOARD_SIZE = exports.BELT_ICON_VIEWBOX = exports.BELT_ICON_PATHS = exports.BELT_COLORS = exports.ALL_TECHNIQUE_IDS = exports.TechniqueId = exports.HINT_LEVEL_LIMITS = void 0;
-exports.successResponse = successResponse;
-exports.errorResponse = errorResponse;
-exports.techniqueToBit = techniqueToBit;
-exports.hasTechnique = hasTechnique;
-exports.addTechnique = addTechnique;
-exports.getBeltForLevel = getBeltForLevel;
-exports.getAllBelts = getAllBelts;
-exports.getBeltIconSvg = getBeltIconSvg;
-exports.getBeltIconForLevel = getBeltIconForLevel;
-exports.parseBoardString = parseBoardString;
-exports.stringifyBoard = stringifyBoard;
-exports.isValidBoardString = isValidBoardString;
-exports.scrambleBoard = scrambleBoard;
-exports.noScramble = noScramble;
-exports.isBoardFilled = isBoardFilled;
-exports.isBoardSolved = isBoardSolved;
-exports.getMergedBoardState = getMergedBoardState;
-exports.hasInvalidPencilmarksStep = hasInvalidPencilmarksStep;
-exports.hasPencilmarkContent = hasPencilmarkContent;
-exports.getTechniqueNameById = getTechniqueNameById;
-exports.cellName = cellName;
-exports.cellList = cellList;
-exports.getBlockIndex = getBlockIndex;
-exports.getBlockNumber = getBlockNumber;
-exports.indexToRowCol = indexToRowCol;
-exports.rowColToIndex = rowColToIndex;
-exports.formatTime = formatTime;
-exports.parseTime = parseTime;
-exports.formatDigits = formatDigits;
-exports.isValidUUID = isValidUUID;
-exports.validateUUID = validateUUID;
-exports.getTechniqueIconUrl = getTechniqueIconUrl;
-/** Create a success response */
-function successResponse(data) {
-    return {
-        success: true,
-        data,
-        timestamp: new Date().toISOString(),
-    };
-}
-/** Create an error response */
-function errorResponse(error) {
-    return {
-        success: false,
-        error,
-        timestamp: new Date().toISOString(),
-    };
-}
-/** Hint level limits by entitlement */
-exports.HINT_LEVEL_LIMITS = {
-    red_belt: Infinity,
-    blue_belt: 5,
-    free: 3,
-};
-// =============================================================================
-// Technique Bitfield (matches SudokuDefines.h enum SudokuTechnique)
-// =============================================================================
-/**
- * Technique IDs matching the solver engine's SudokuTechnique enum.
- * Used as bitfield values in boards.techniques and technique_examples.techniques_bitfield.
- */
-var TechniqueId;
-(function (TechniqueId) {
-    TechniqueId[TechniqueId["FULL_HOUSE"] = 1] = "FULL_HOUSE";
-    TechniqueId[TechniqueId["HIDDEN_SINGLE"] = 2] = "HIDDEN_SINGLE";
-    TechniqueId[TechniqueId["NAKED_SINGLE"] = 3] = "NAKED_SINGLE";
-    TechniqueId[TechniqueId["HIDDEN_PAIR"] = 4] = "HIDDEN_PAIR";
-    TechniqueId[TechniqueId["NAKED_PAIR"] = 5] = "NAKED_PAIR";
-    TechniqueId[TechniqueId["LOCKED_CANDIDATES"] = 6] = "LOCKED_CANDIDATES";
-    TechniqueId[TechniqueId["HIDDEN_TRIPLE"] = 7] = "HIDDEN_TRIPLE";
-    TechniqueId[TechniqueId["NAKED_TRIPLE"] = 8] = "NAKED_TRIPLE";
-    TechniqueId[TechniqueId["HIDDEN_QUAD"] = 9] = "HIDDEN_QUAD";
-    TechniqueId[TechniqueId["NAKED_QUAD"] = 10] = "NAKED_QUAD";
-    TechniqueId[TechniqueId["X_WING"] = 11] = "X_WING";
-    TechniqueId[TechniqueId["SWORDFISH"] = 12] = "SWORDFISH";
-    TechniqueId[TechniqueId["JELLYFISH"] = 13] = "JELLYFISH";
-    TechniqueId[TechniqueId["XY_WING"] = 14] = "XY_WING";
-    TechniqueId[TechniqueId["FINNED_X_WING"] = 15] = "FINNED_X_WING";
-    TechniqueId[TechniqueId["SQUIRMBAG"] = 16] = "SQUIRMBAG";
-    TechniqueId[TechniqueId["FINNED_SWORDFISH"] = 17] = "FINNED_SWORDFISH";
-    TechniqueId[TechniqueId["FINNED_JELLYFISH"] = 18] = "FINNED_JELLYFISH";
-    TechniqueId[TechniqueId["XYZ_WING"] = 19] = "XYZ_WING";
-    TechniqueId[TechniqueId["WXYZ_WING"] = 20] = "WXYZ_WING";
-    TechniqueId[TechniqueId["ALMOST_LOCKED_SETS"] = 21] = "ALMOST_LOCKED_SETS";
-    TechniqueId[TechniqueId["FINNED_SQUIRMBAG"] = 22] = "FINNED_SQUIRMBAG";
-    TechniqueId[TechniqueId["ALS_CHAIN"] = 23] = "ALS_CHAIN";
-    TechniqueId[TechniqueId["SKYSCRAPER"] = 24] = "SKYSCRAPER";
-    TechniqueId[TechniqueId["TWO_STRING_KITE"] = 25] = "TWO_STRING_KITE";
-    TechniqueId[TechniqueId["EMPTY_RECTANGLE"] = 26] = "EMPTY_RECTANGLE";
-    TechniqueId[TechniqueId["SIMPLE_COLORING"] = 27] = "SIMPLE_COLORING";
-    TechniqueId[TechniqueId["W_WING"] = 28] = "W_WING";
-    TechniqueId[TechniqueId["REMOTE_PAIRS"] = 29] = "REMOTE_PAIRS";
-    TechniqueId[TechniqueId["UNIQUE_RECTANGLE_1"] = 30] = "UNIQUE_RECTANGLE_1";
-    TechniqueId[TechniqueId["UNIQUE_RECTANGLE_2"] = 31] = "UNIQUE_RECTANGLE_2";
-    TechniqueId[TechniqueId["BUG_PLUS_1"] = 32] = "BUG_PLUS_1";
-    TechniqueId[TechniqueId["SUE_DE_COQ"] = 33] = "SUE_DE_COQ";
-    TechniqueId[TechniqueId["ALS_XZ"] = 34] = "ALS_XZ";
-    TechniqueId[TechniqueId["X_CYCLES"] = 35] = "X_CYCLES";
-    TechniqueId[TechniqueId["FORCING_CHAINS"] = 36] = "FORCING_CHAINS";
-    TechniqueId[TechniqueId["MEDUSA_COLORING"] = 37] = "MEDUSA_COLORING";
-    TechniqueId[TechniqueId["CRANE"] = 38] = "CRANE";
-    TechniqueId[TechniqueId["UNIQUE_RECTANGLE_3"] = 39] = "UNIQUE_RECTANGLE_3";
-    TechniqueId[TechniqueId["UNIQUE_RECTANGLE_4"] = 40] = "UNIQUE_RECTANGLE_4";
-    TechniqueId[TechniqueId["UNIQUE_RECTANGLE_5"] = 41] = "UNIQUE_RECTANGLE_5";
-    TechniqueId[TechniqueId["X_CHAIN"] = 42] = "X_CHAIN";
-    TechniqueId[TechniqueId["XY_CHAIN"] = 43] = "XY_CHAIN";
-    TechniqueId[TechniqueId["VWXYZ_WING"] = 44] = "VWXYZ_WING";
-    TechniqueId[TechniqueId["UVWXYZ_WING"] = 45] = "UVWXYZ_WING";
-    TechniqueId[TechniqueId["TUVWXYZ_WING"] = 46] = "TUVWXYZ_WING";
-    TechniqueId[TechniqueId["STUVWXYZ_WING"] = 47] = "STUVWXYZ_WING";
-    TechniqueId[TechniqueId["AIC"] = 48] = "AIC";
-    TechniqueId[TechniqueId["FORCING_NET"] = 49] = "FORCING_NET";
-    TechniqueId[TechniqueId["AVOIDABLE_RECTANGLE"] = 50] = "AVOIDABLE_RECTANGLE";
-    TechniqueId[TechniqueId["SASHIMI_X_WING"] = 51] = "SASHIMI_X_WING";
-    TechniqueId[TechniqueId["SASHIMI_SWORDFISH"] = 52] = "SASHIMI_SWORDFISH";
-    TechniqueId[TechniqueId["SASHIMI_JELLYFISH"] = 53] = "SASHIMI_JELLYFISH";
-    TechniqueId[TechniqueId["HIDDEN_UNIQUE_RECTANGLE"] = 54] = "HIDDEN_UNIQUE_RECTANGLE";
-    TechniqueId[TechniqueId["FIREWORK"] = 55] = "FIREWORK";
-    TechniqueId[TechniqueId["DEATH_BLOSSOM"] = 56] = "DEATH_BLOSSOM";
-    TechniqueId[TechniqueId["FRANKEN_X_WING"] = 57] = "FRANKEN_X_WING";
-    TechniqueId[TechniqueId["FRANKEN_SWORDFISH"] = 58] = "FRANKEN_SWORDFISH";
-    TechniqueId[TechniqueId["FRANKEN_JELLYFISH"] = 59] = "FRANKEN_JELLYFISH";
-    TechniqueId[TechniqueId["GROUPED_X_CYCLES"] = 60] = "GROUPED_X_CYCLES";
-})(TechniqueId || (exports.TechniqueId = TechniqueId = {}));
-/** All technique IDs sorted by value (ascending) */
-exports.ALL_TECHNIQUE_IDS = Object.values(TechniqueId).filter((v) => typeof v === 'number');
-/**
- * Convert a TechniqueId to its bit value in the bitfield.
- * TechniqueId N maps to bit N (1 << N).
- *
- * Uses BigInt internally to support techniques >= 32, then converts to Number.
- *
- * **Precision warning:** Safe for technique IDs < 53 (since 2^52 is within
- * `Number.MAX_SAFE_INTEGER`). For IDs >= 53, the Number conversion may lose
- * precision. Currently all defined techniques (1-60) include IDs up to 60,
- * so IDs 53-60 may produce imprecise results when converted to Number.
- *
- * @param techniqueId - The technique ID from {@link TechniqueId} enum
- * @returns The bit value as a number (1 << techniqueId)
- */
-function techniqueToBit(techniqueId) {
-    return Number(BigInt(1) << BigInt(techniqueId));
-}
-/**
- * Check if a technique is present in a bitfield.
- * Uses BigInt internally to support techniques >= 32.
- *
- * @param bitfield - The techniques bitmask (from {@link Board.techniques} or {@link Daily.techniques})
- * @param techniqueId - The technique ID to check
- * @returns true if the technique bit is set in the bitfield
- */
-function hasTechnique(bitfield, techniqueId) {
-    const bit = BigInt(1) << BigInt(techniqueId);
-    return (BigInt(bitfield) & bit) !== BigInt(0);
-}
-/**
- * Add a technique to a bitfield by setting its bit.
- * Uses BigInt internally to support techniques >= 32.
- *
- * **Precision warning:** The result is converted back to Number, which may
- * lose precision if the resulting bitfield exceeds `Number.MAX_SAFE_INTEGER`
- * (i.e., when techniques with IDs >= 53 are included).
- *
- * @param bitfield - The current techniques bitmask
- * @param techniqueId - The technique ID to add
- * @returns The updated bitmask with the technique bit set
- */
-function addTechnique(bitfield, techniqueId) {
-    const bit = BigInt(1) << BigInt(techniqueId);
-    return Number(BigInt(bitfield) | bit);
-}
-/** Belt colors mapped to level index (1-12) */
-exports.BELT_COLORS = {
-    1: { name: 'White', hex: '#FFFFFF' },
-    2: { name: 'White (Yellow Stripe)', hex: '#FFFFFF', stripeHex: '#FFEB3B' },
-    3: { name: 'Yellow', hex: '#FFEB3B' },
-    4: { name: 'Yellow (Orange Stripe)', hex: '#FFEB3B', stripeHex: '#FF9800' },
-    5: { name: 'Orange', hex: '#FF9800' },
-    6: { name: 'Orange (Green Stripe)', hex: '#FF9800', stripeHex: '#4CAF50' },
-    7: { name: 'Green', hex: '#4CAF50' },
-    8: { name: 'Blue', hex: '#2196F3' },
-    9: { name: 'Purple', hex: '#9C27B0' },
-    10: { name: 'Brown', hex: '#795548' },
-    11: { name: 'Red', hex: '#F44336' },
-    12: { name: 'Black', hex: '#212121' },
-};
-/** Get the belt for a given level index (1-12) */
-function getBeltForLevel(levelIndex) {
-    return exports.BELT_COLORS[levelIndex] ?? null;
-}
-/** Get all belts as an array ordered by level */
-function getAllBelts() {
-    return Object.values(exports.BELT_COLORS);
-}
-/**
- * SVG paths for the martial arts belt icon.
- * Based on Wikimedia Commons Judo belt design.
- * ViewBox: 0 0 478.619 184.676
- */
-exports.BELT_ICON_PATHS = [
-    'M192.044,46.054c0,0-1.475,4.952,0.21,7.375c1.686,2.423,24.86,1.791,24.86,1.791L205.845,45L192.044,46.054z',
-    'M9.831,23.198c0,0,119.181,32.087,233.779,32.087c114.598,0,214.679-51.187,218.5-53.479c3.819-2.292,12.987,38.963,0.765,48.131c-12.225,9.168-80.983,48.896-216.208,48.896c-135.226,0-233.015-21.392-239.892-29.032C-0.101,62.161-0.101,31.602,9.831,23.198z',
-    'M252.014,126.336c0,0-22.156-6.112-28.268-21.392c-6.111-15.279,58.827-29.795,58.827-29.795l-6.112,31.324L252.014,126.336z',
-    'M195.479,102.652c0,0,30.56,21.392,35.143,19.1c4.584-2.292,58.827-36.671,58.827-36.671L243.61,51.465l-50.423,38.2L195.479,102.652z',
-    'M22.818,152.312c0,0,125.293-76.398,200.928-106.958c75.635-30.56,30.56,29.031,30.56,29.031s-78.69,38.199-110.778,57.299s-81.746,50.424-87.858,51.188C49.558,183.635,22.818,152.312,22.818,152.312z',
-    'M255.967,27.303c0,0-5.29-1.851-14.146,8.46c-8.857,10.312,15.07,8.197,15.07,8.197L255.967,27.303z',
-    'M232.15,28.546c0,0,94.734,49.659,127.586,60.355c32.851,10.696,113.832,46.603,116.889,55.771s-27.503,30.559-27.503,30.559s-23.685-21.391-54.243-34.379c-30.56-12.987-83.274-34.379-112.306-48.131c-29.031-13.751-89.387-47.367-89.387-47.367L232.15,28.546z',
-    'M255.834,27.782c0,0-2.292,92.442-4.584,97.026c-2.293,4.584,42.783-12.987,43.546-18.335c0.765-5.349,6.877-50.423,2.293-55.007S260.417,25.49,255.834,27.782z',
-];
-/** Original viewBox for the belt icon */
-exports.BELT_ICON_VIEWBOX = '0 0 478.619 184.676';
-/**
- * Generate a complete SVG string for the martial arts belt icon.
- * Uses black stroke for all colors except black belt, which uses white stroke.
- * Supports optional stripe color for striped belt variants.
- *
- * Stripes are placed at the tips/ends of the belt tails (as per real karate belt conventions),
- * not across the center of the belt.
- *
- * @param fill - Fill color for the belt
- * @param width - Width in pixels (default: 100)
- * @param height - Height in pixels (default: 40)
- * @param strokeColor - Stroke color (default: auto-detected based on fill)
- * @param stripeColor - Optional stripe color for striped belt variants (placed at belt tips)
- *
- * @example
- * // Get SVG for blue belt:
- * const svg = getBeltIconSvg('#2196F3');
- *
- * // Get SVG for black belt (auto white stroke):
- * const svg = getBeltIconSvg('#212121');
- *
- * // Get SVG for white belt with yellow stripe:
- * const svg = getBeltIconSvg('#FFFFFF', 100, 40, undefined, '#FFEB3B');
- *
- * // React with dangerouslySetInnerHTML:
- * <div dangerouslySetInnerHTML={{ __html: getBeltIconSvg(belt.hex, 100, 40, undefined, belt.stripeHex) }} />
- */
-function getBeltIconSvg(fill, width = 100, height = 40, strokeColor, stripeColor) {
-    // Auto-detect stroke color: use white for dark fills (black belt)
-    const stroke = strokeColor ??
-        (fill.toLowerCase() === '#212121' || fill.toLowerCase() === '#000000'
-            ? '#FFFFFF'
-            : '#000000');
-    const paths = exports.BELT_ICON_PATHS.map((d) => `<path fill="${fill}" stroke="${stroke}" stroke-width="4" d="${d}"/>`).join('');
-    // Add stripes at the belt tail tips if stripeColor is provided
-    // Real karate belt stripes are placed at the END of the belt (near the tips), not across the center
-    // The belt has two tails: left tail (lower-left) and right tail (upper-right)
-    const stripes = stripeColor
-        ? `
-      <rect x="25" y="158" width="50" height="18" fill="${stripeColor}" stroke="${stroke}" stroke-width="1.5" transform="rotate(-20, 50, 167)" clip-path="url(#beltClip)"/>
-      <rect x="425" y="148" width="50" height="18" fill="${stripeColor}" stroke="${stroke}" stroke-width="1.5" transform="rotate(20, 450, 157)" clip-path="url(#beltClip)"/>
-    `
-        : '';
-    // Create a clip path using the belt paths for proper stripe clipping
-    const clipPath = stripeColor
-        ? `<defs><clipPath id="beltClip">${exports.BELT_ICON_PATHS.map((d) => `<path d="${d}"/>`).join('')}</clipPath></defs>`
-        : '';
-    return `<svg xmlns="http://www.w3.org/2000/svg" viewBox="${exports.BELT_ICON_VIEWBOX}" width="${width}" height="${height}">${clipPath}${paths}${stripes}</svg>`;
-}
-/**
- * Generate belt icon SVG for a specific level index.
- * Convenience function that combines getBeltForLevel and getBeltIconSvg.
- * Automatically includes stripe if the belt has one.
- *
- * @param levelIndex - Level index (1-12)
- * @param width - Width in pixels (default: 100)
- * @param height - Height in pixels (default: 40)
- * @returns SVG string or null if level is invalid
- */
-function getBeltIconForLevel(levelIndex, width = 100, height = 40) {
-    const belt = getBeltForLevel(levelIndex);
-    if (!belt)
-        return null;
-    return getBeltIconSvg(belt.hex, width, height, undefined, belt.stripeHex);
-}
-// =============================================================================
-// Board Utilities (for parsing and manipulating Sudoku boards)
-// =============================================================================
-/** Board size constant (9x9 grid) */
-exports.BOARD_SIZE = 9;
-/** Block size constant (3x3 blocks) */
-exports.BLOCK_SIZE = 3;
-/** Total cells in a board */
-exports.TOTAL_CELLS = exports.BOARD_SIZE * exports.BOARD_SIZE;
-/**
- * Parses an 81-character board string into a 2D array of numbers
- * @param boardString - 81-character string where '0' or '.' represents empty cells
- * @returns 9x9 array of numbers (0 = empty, 1-9 = filled)
- */
-function parseBoardString(boardString) {
-    if (boardString.length !== exports.TOTAL_CELLS) {
-        throw new Error(`Invalid board string length: expected ${exports.TOTAL_CELLS}, got ${boardString.length}`);
-    }
-    const board = [];
-    for (let row = 0; row < exports.BOARD_SIZE; row++) {
-        const rowArray = [];
-        for (let col = 0; col < exports.BOARD_SIZE; col++) {
-            const index = row * exports.BOARD_SIZE + col;
-            const char = boardString[index];
-            if (char === undefined) {
-                throw new Error(`Missing character at position ${index}`);
-            }
-            const value = char === '.' ? 0 : parseInt(char, 10);
-            if (isNaN(value) || value < 0 || value > 9) {
-                throw new Error(`Invalid character at position ${index}: '${char}'`);
-            }
-            rowArray.push(value);
-        }
-        board.push(rowArray);
-    }
-    return board;
-}
-/**
- * Converts a 2D number array back to an 81-character string
- * @param board - 9x9 array of numbers
- * @returns 81-character string
- */
-function stringifyBoard(board) {
-    if (board.length !== exports.BOARD_SIZE) {
-        throw new Error(`Invalid board rows: expected ${exports.BOARD_SIZE}, got ${board.length}`);
-    }
-    let result = '';
-    for (let row = 0; row < exports.BOARD_SIZE; row++) {
-        if (board[row]?.length !== exports.BOARD_SIZE) {
-            throw new Error(`Invalid row ${row} length: expected ${exports.BOARD_SIZE}, got ${board[row]?.length}`);
-        }
-        for (let col = 0; col < exports.BOARD_SIZE; col++) {
-            const value = board[row]?.[col];
-            if (value === undefined || value < 0 || value > 9) {
-                throw new Error(`Invalid value at (${row}, ${col}): ${value}`);
-            }
-            result += value.toString();
-        }
-    }
-    return result;
-}
-/** Pattern matching a valid 81-character board string (digits 0-9 and dots) */
-const BOARD_STRING_PATTERN = /^[0-9.]{81}$/;
-/**
- * Validate that a string is a well-formed 81-character board string.
- * A valid board string consists of exactly 81 characters, each being a digit
- * ('0'-'9') or a dot ('.'), where '0' and '.' represent empty cells.
- *
- * This is a lightweight validation that checks format only -- it does not
- * verify that the board represents a solvable or valid Sudoku puzzle.
- *
- * @param s - The string to validate
- * @returns true if the string is a valid board string format
- *
- * @example
- * ```typescript
- * isValidBoardString('530070000600195000098000060800060003400803001700020006060000280000419005000080079'); // true
- * isValidBoardString('.'.repeat(81)); // true (all empty)
- * isValidBoardString('0'.repeat(81)); // true (all empty)
- * isValidBoardString('short');        // false (wrong length)
- * isValidBoardString('x'.repeat(81)); // false (invalid characters)
- * ```
- */
-function isValidBoardString(s) {
-    return BOARD_STRING_PATTERN.test(s);
-}
-/**
- * Default scramble configuration (all transformations enabled)
- */
-exports.DEFAULT_SCRAMBLE_CONFIG = {
-    scrambleRows: true,
-    scrambleColumns: true,
-    scrambleRowBlocks: true,
-    scrambleColumnBlocks: true,
-    scrambleDigits: true,
-    rotate: true,
-    mirror: true,
-};
-/**
- * Fisher-Yates shuffle algorithm for arrays.
- *
- * Uses `Math.random()` which is non-deterministic and not
- * cryptographically secure. Scramble results are intended for visual
- * variety, not for security purposes.
- */
-function shuffleArray(array) {
-    for (let i = array.length - 1; i > 0; i--) {
-        const j = Math.floor(Math.random() * (i + 1));
-        const temp = array[i];
-        array[i] = array[j];
-        array[j] = temp;
-    }
-    return array;
-}
-/**
- * Creates a random digit mapping (1-9 -> 1-9)
- */
-function createDigitMapping() {
-    const digits = [1, 2, 3, 4, 5, 6, 7, 8, 9];
-    const shuffled = shuffleArray([...digits]);
-    const mapping = new Map();
-    for (let i = 0; i < digits.length; i++) {
-        mapping.set(digits[i], shuffled[i]);
-    }
-    return mapping;
-}
-/**
- * Creates the reverse of a digit mapping
- */
-function reverseDigitMapping(mapping) {
-    const reverse = new Map();
-    for (const [original, scrambled] of mapping) {
-        reverse.set(scrambled, original);
-    }
-    return reverse;
-}
-/**
- * Applies digit mapping to a board
- */
-function applyDigitMapping(board, mapping) {
-    return board.map((row) => row.map((value) => {
-        if (value === 0)
-            return 0;
-        return mapping.get(value) ?? value;
-    }));
-}
-/**
- * Rotates the board 90 degrees clockwise
- */
-function rotateBoard90(board) {
-    const rotated = [];
-    for (let col = 0; col < exports.BOARD_SIZE; col++) {
-        const newRow = [];
-        for (let row = exports.BOARD_SIZE - 1; row >= 0; row--) {
-            newRow.push(board[row]?.[col] ?? 0);
-        }
-        rotated.push(newRow);
-    }
-    return rotated;
-}
-/**
- * Mirrors the board horizontally (left-right)
- */
-function mirrorHorizontally(board) {
-    return board.map((row) => [...row].reverse());
-}
-/**
- * Mirrors the board vertically (top-bottom)
- */
-function mirrorVertically(board) {
-    return [...board].reverse().map((row) => [...row]);
-}
-/**
- * Scrambles a Sudoku board while preserving its logical structure.
- *
- * Scrambling preserves the logical structure of a Sudoku puzzle while making it
- * appear different. This is useful for:
- * - Preventing players from recognizing puzzles they've seen before
- * - Creating variety from a limited puzzle database
- * - Making it harder to look up solutions online
- *
- * @param puzzle - 81-character puzzle string
- * @param solution - 81-character solution string
- * @param config - Scramble configuration (defaults to all transformations enabled)
- * @returns Scramble result with scrambled puzzle, solution, and digit mapping
- *
- * @example
- * ```typescript
- * const result = scrambleBoard(puzzle, solution);
- * console.log(result.puzzle);      // Scrambled puzzle
- * console.log(result.solution);    // Scrambled solution
- * console.log(result.digitMapping); // Map from original to scrambled digits
- * ```
- */
-function scrambleBoard(puzzle, solution, config = exports.DEFAULT_SCRAMBLE_CONFIG) {
-    // Parse the boards
-    let puzzleBoard = parseBoardString(puzzle);
-    let solutionBoard = parseBoardString(solution);
-    // Create digit mapping (applied to both puzzle and solution)
-    let digitMapping = new Map();
-    for (let i = 1; i <= 9; i++) {
-        digitMapping.set(i, i); // Identity mapping by default
-    }
-    if (config.scrambleDigits) {
-        digitMapping = createDigitMapping();
-        puzzleBoard = applyDigitMapping(puzzleBoard, digitMapping);
-        solutionBoard = applyDigitMapping(solutionBoard, digitMapping);
-    }
-    // Scramble rows within blocks
-    if (config.scrambleRows) {
-        const rowPermutations = [];
-        for (let blockRow = 0; blockRow < exports.BLOCK_SIZE; blockRow++) {
-            rowPermutations.push(shuffleArray([0, 1, 2]));
-        }
-        const applyRowPermutation = (board) => {
-            for (let blockRow = 0; blockRow < exports.BLOCK_SIZE; blockRow++) {
-                const startRow = blockRow * exports.BLOCK_SIZE;
-                const perm = rowPermutations[blockRow];
-                const rowsCopy = [
-                    [...(board[startRow] ?? [])],
-                    [...(board[startRow + 1] ?? [])],
-                    [...(board[startRow + 2] ?? [])],
-                ];
-                for (let i = 0; i < exports.BLOCK_SIZE; i++) {
-                    board[startRow + i] = rowsCopy[perm[i]];
-                }
-            }
-        };
-        applyRowPermutation(puzzleBoard);
-        applyRowPermutation(solutionBoard);
-    }
-    // Scramble columns within blocks
-    if (config.scrambleColumns) {
-        const colPermutations = [];
-        for (let blockCol = 0; blockCol < exports.BLOCK_SIZE; blockCol++) {
-            colPermutations.push(shuffleArray([0, 1, 2]));
-        }
-        const applyColPermutation = (board) => {
-            for (let blockCol = 0; blockCol < exports.BLOCK_SIZE; blockCol++) {
-                const startCol = blockCol * exports.BLOCK_SIZE;
-                const perm = colPermutations[blockCol];
-                for (let row = 0; row < exports.BOARD_SIZE; row++) {
-                    const boardRow = board[row];
-                    if (boardRow) {
-                        const colsCopy = [
-                            boardRow[startCol],
-                            boardRow[startCol + 1],
-                            boardRow[startCol + 2],
-                        ];
-                        for (let i = 0; i < exports.BLOCK_SIZE; i++) {
-                            boardRow[startCol + i] = colsCopy[perm[i]];
-                        }
-                    }
-                }
-            }
-        };
-        applyColPermutation(puzzleBoard);
-        applyColPermutation(solutionBoard);
-    }
-    // Scramble row blocks
-    if (config.scrambleRowBlocks) {
-        const blockOrder = shuffleArray([0, 1, 2]);
-        const applyRowBlockPermutation = (board) => {
-            const allRows = board.map((row) => [...row]);
-            const result = [];
-            for (let newBlockIndex = 0; newBlockIndex < exports.BLOCK_SIZE; newBlockIndex++) {
-                const oldBlockIndex = blockOrder[newBlockIndex];
-                for (let i = 0; i < exports.BLOCK_SIZE; i++) {
-                    result.push(allRows[oldBlockIndex * exports.BLOCK_SIZE + i]);
-                }
-            }
-            return result;
-        };
-        puzzleBoard = applyRowBlockPermutation(puzzleBoard);
-        solutionBoard = applyRowBlockPermutation(solutionBoard);
-    }
-    // Scramble column blocks
-    if (config.scrambleColumnBlocks) {
-        const blockOrder = shuffleArray([0, 1, 2]);
-        const applyColBlockPermutation = (board) => {
-            const result = board.map(() => new Array(exports.BOARD_SIZE).fill(0));
-            for (let newBlockIndex = 0; newBlockIndex < exports.BLOCK_SIZE; newBlockIndex++) {
-                const oldBlockIndex = blockOrder[newBlockIndex];
-                for (let i = 0; i < exports.BLOCK_SIZE; i++) {
-                    const oldCol = oldBlockIndex * exports.BLOCK_SIZE + i;
-                    const newCol = newBlockIndex * exports.BLOCK_SIZE + i;
-                    for (let row = 0; row < exports.BOARD_SIZE; row++) {
-                        const resultRow = result[row];
-                        if (resultRow) {
-                            resultRow[newCol] = board[row]?.[oldCol] ?? 0;
-                        }
-                    }
-                }
-            }
-            return result;
-        };
-        puzzleBoard = applyColBlockPermutation(puzzleBoard);
-        solutionBoard = applyColBlockPermutation(solutionBoard);
-    }
-    // Rotate
-    if (config.rotate) {
-        const rotations = Math.floor(Math.random() * 4);
-        for (let i = 0; i < rotations; i++) {
-            puzzleBoard = rotateBoard90(puzzleBoard);
-            solutionBoard = rotateBoard90(solutionBoard);
-        }
-    }
-    // Mirror
-    if (config.mirror) {
-        const mirrorType = Math.floor(Math.random() * 4);
-        const applyMirror = (board) => {
-            switch (mirrorType) {
-                case 1:
-                    return mirrorHorizontally(board);
-                case 2:
-                    return mirrorVertically(board);
-                case 3:
-                    return mirrorVertically(mirrorHorizontally(board));
-                default:
-                    return board;
-            }
-        };
-        puzzleBoard = applyMirror(puzzleBoard);
-        solutionBoard = applyMirror(solutionBoard);
-    }
-    return {
-        puzzle: stringifyBoard(puzzleBoard),
-        solution: stringifyBoard(solutionBoard),
-        digitMapping,
-        reverseDigitMapping: reverseDigitMapping(digitMapping),
-    };
-}
-/**
- * Creates an identity scramble result (no scrambling)
- * @param puzzle - 81-character puzzle string
- * @param solution - 81-character solution string
- * @returns ScrambleResult with identity mapping
- */
-function noScramble(puzzle, solution) {
-    const identityMapping = new Map();
-    for (let i = 1; i <= 9; i++) {
-        identityMapping.set(i, i);
-    }
-    return {
-        puzzle,
-        solution,
-        digitMapping: identityMapping,
-        reverseDigitMapping: identityMapping,
-    };
-}
-// =============================================================================
-// Solver Utilities (shared between frontend and backend)
-// =============================================================================
-/**
- * Check if all cells are filled (no empty cells remaining).
- * A cell is considered filled if either the original puzzle has a digit
- * or the user has entered a digit.
- *
- * @param original - 81-char original puzzle string (0 = empty)
- * @param user - 81-char user input string (0 = no input)
- * @returns true if all 81 cells have a non-zero digit
- *
- * @example
- * ```typescript
- * const original = '530070000...'; // partial puzzle
- * const user = '000000000...';     // no user input yet
- * isBoardFilled(original, user);   // false
- * ```
- */
-function isBoardFilled(original, user) {
-    for (let i = 0; i < exports.TOTAL_CELLS; i++) {
-        const originalChar = original[i] || '0';
-        const userChar = user[i] || '0';
-        const actualChar = userChar !== '0' ? userChar : originalChar;
-        if (actualChar === '0')
-            return false;
-    }
-    return true;
-}
-/**
- * Check if all cells are filled AND match the solution.
- * Useful for validating that a puzzle is correctly solved.
- *
- * @param original - 81-char original puzzle string (0 = empty)
- * @param user - 81-char user input string (0 = no input)
- * @param solution - 81-char solution string
- * @returns true if board is filled and all values match solution
- *
- * @example
- * ```typescript
- * isBoardSolved(original, userInput, solution); // true if correctly solved
- * ```
- */
-function isBoardSolved(original, user, solution) {
-    for (let i = 0; i < exports.TOTAL_CELLS; i++) {
-        const originalChar = original[i] || '0';
-        const userChar = user[i] || '0';
-        const solutionChar = solution[i] || '0';
-        const actualChar = userChar !== '0' ? userChar : originalChar;
-        if (actualChar === '0')
-            return false;
-        if (actualChar !== solutionChar)
-            return false;
-    }
-    return true;
-}
-/**
- * Get the current board state by merging original puzzle and user input.
- * For each cell, returns the user's input if non-zero, otherwise the original value.
- *
- * @param original - 81-char original puzzle string (0 = empty)
- * @param user - 81-char user input string (0 = no input)
- * @returns 81-char string representing current board state
- *
- * @example
- * ```typescript
- * const original = '530070000...';
- * const user = '006000000...';
- * getMergedBoardState(original, user); // '536070000...'
- * ```
- */
-function getMergedBoardState(original, user) {
-    let result = '';
-    for (let i = 0; i < exports.TOTAL_CELLS; i++) {
-        const originalChar = original[i] || '0';
-        const userChar = user[i] || '0';
-        result += userChar !== '0' ? userChar : originalChar;
-    }
-    return result;
-}
-/**
- * Check for "Invalid Pencilmarks" error in hint steps.
- * This indicates the solver detected inconsistent pencilmarks.
- *
- * @param steps - Array of hint steps from solver response
- * @returns true if any step has title "Invalid Pencilmarks"
- *
- * @example
- * ```typescript
- * if (hasInvalidPencilmarksStep(response.data.hints.steps)) {
- *   throw new Error('Invalid pencilmarks detected');
- * }
- * ```
- */
-function hasInvalidPencilmarksStep(steps) {
-    if (!steps)
-        return false;
-    return steps.some(step => step.title === 'Invalid Pencilmarks');
-}
-/**
- * Check if pencilmarks string has actual content (not just empty commas).
- * Pencilmarks are stored as comma-separated values like "123,45,9,,...".
- * An "empty" pencilmarks string would be all commas: ",,,,,...".
- *
- * @param pencilmarks - Comma-separated pencilmarks string
- * @returns true if there are actual pencilmark values
- *
- * @example
- * ```typescript
- * hasPencilmarkContent('123,45,,9,');  // true
- * hasPencilmarkContent(',,,,,,,,');    // false
- * hasPencilmarkContent('');            // false
- * ```
- */
-function hasPencilmarkContent(pencilmarks) {
-    return pencilmarks.replace(/,/g, '').length > 0;
-}
-/**
- * Map from TechniqueId to display title.
- * Covers all defined technique IDs (1-60).
- */
-const TECHNIQUE_ID_TO_TITLE = {
-    [TechniqueId.FULL_HOUSE]: 'Full House',
-    [TechniqueId.HIDDEN_SINGLE]: 'Hidden Single',
-    [TechniqueId.NAKED_SINGLE]: 'Naked Single',
-    [TechniqueId.HIDDEN_PAIR]: 'Hidden Pair',
-    [TechniqueId.NAKED_PAIR]: 'Naked Pair',
-    [TechniqueId.LOCKED_CANDIDATES]: 'Locked Candidates',
-    [TechniqueId.HIDDEN_TRIPLE]: 'Hidden Triple',
-    [TechniqueId.NAKED_TRIPLE]: 'Naked Triple',
-    [TechniqueId.HIDDEN_QUAD]: 'Hidden Quad',
-    [TechniqueId.NAKED_QUAD]: 'Naked Quad',
-    [TechniqueId.X_WING]: 'X-Wing',
-    [TechniqueId.SWORDFISH]: 'Swordfish',
-    [TechniqueId.JELLYFISH]: 'Jellyfish',
-    [TechniqueId.XY_WING]: 'XY-Wing',
-    [TechniqueId.FINNED_X_WING]: 'Finned X-Wing',
-    [TechniqueId.SQUIRMBAG]: 'Squirmbag',
-    [TechniqueId.FINNED_SWORDFISH]: 'Finned Swordfish',
-    [TechniqueId.FINNED_JELLYFISH]: 'Finned Jellyfish',
-    [TechniqueId.XYZ_WING]: 'XYZ-Wing',
-    [TechniqueId.WXYZ_WING]: 'WXYZ-Wing',
-    [TechniqueId.ALMOST_LOCKED_SETS]: 'Almost Locked Sets',
-    [TechniqueId.FINNED_SQUIRMBAG]: 'Finned Squirmbag',
-    [TechniqueId.ALS_CHAIN]: 'ALS Chain',
-    [TechniqueId.SKYSCRAPER]: 'Skyscraper',
-    [TechniqueId.TWO_STRING_KITE]: 'Two-String Kite',
-    [TechniqueId.EMPTY_RECTANGLE]: 'Empty Rectangle',
-    [TechniqueId.SIMPLE_COLORING]: 'Simple Coloring',
-    [TechniqueId.W_WING]: 'W-Wing',
-    [TechniqueId.REMOTE_PAIRS]: 'Remote Pairs',
-    [TechniqueId.UNIQUE_RECTANGLE_1]: 'Unique Rectangle Type 1',
-    [TechniqueId.UNIQUE_RECTANGLE_2]: 'Unique Rectangle Type 2',
-    [TechniqueId.BUG_PLUS_1]: 'BUG+1',
-    [TechniqueId.SUE_DE_COQ]: 'Sue de Coq',
-    [TechniqueId.ALS_XZ]: 'ALS-XZ',
-    [TechniqueId.X_CYCLES]: 'X-Cycles',
-    [TechniqueId.FORCING_CHAINS]: 'Forcing Chains',
-    [TechniqueId.MEDUSA_COLORING]: '3D Medusa',
-    [TechniqueId.CRANE]: 'Crane',
-    [TechniqueId.UNIQUE_RECTANGLE_3]: 'Unique Rectangle Type 3',
-    [TechniqueId.UNIQUE_RECTANGLE_4]: 'Unique Rectangle Type 4',
-    [TechniqueId.UNIQUE_RECTANGLE_5]: 'Unique Rectangle Type 5',
-    [TechniqueId.X_CHAIN]: 'X-Chain',
-    [TechniqueId.XY_CHAIN]: 'XY-Chain',
-    [TechniqueId.VWXYZ_WING]: 'VWXYZ-Wing',
-    [TechniqueId.UVWXYZ_WING]: 'UVWXYZ-Wing',
-    [TechniqueId.TUVWXYZ_WING]: 'TUVWXYZ-Wing',
-    [TechniqueId.STUVWXYZ_WING]: 'STUVWXYZ-Wing',
-    [TechniqueId.AIC]: 'AIC',
-    [TechniqueId.FORCING_NET]: 'Forcing Net',
-    [TechniqueId.AVOIDABLE_RECTANGLE]: 'Avoidable Rectangle',
-    [TechniqueId.SASHIMI_X_WING]: 'Sashimi X-Wing',
-    [TechniqueId.SASHIMI_SWORDFISH]: 'Sashimi Swordfish',
-    [TechniqueId.SASHIMI_JELLYFISH]: 'Sashimi Jellyfish',
-    [TechniqueId.HIDDEN_UNIQUE_RECTANGLE]: 'Hidden Unique Rectangle',
-    [TechniqueId.FIREWORK]: 'Firework',
-    [TechniqueId.DEATH_BLOSSOM]: 'Death Blossom',
-    [TechniqueId.FRANKEN_X_WING]: 'Franken X-Wing',
-    [TechniqueId.FRANKEN_SWORDFISH]: 'Franken Swordfish',
-    [TechniqueId.FRANKEN_JELLYFISH]: 'Franken Jellyfish',
-    [TechniqueId.GROUPED_X_CYCLES]: 'Grouped X-Cycles',
-};
-/**
- * Get the technique title/name from its ID.
- *
- * @param techniqueId - The technique ID number
- * @returns The technique title, or "Technique {id}" if unknown
- *
- * @example
- * ```typescript
- * getTechniqueNameById(1);  // "Full House"
- * getTechniqueNameById(14); // "XY-Wing"
- * getTechniqueNameById(999); // "Technique 999"
- * ```
- */
-function getTechniqueNameById(techniqueId) {
-    return (TECHNIQUE_ID_TO_TITLE[techniqueId] ??
-        `Technique ${techniqueId}`);
-}
-// =============================================================================
-// Board State Constants
-// =============================================================================
-/**
- * Empty board string (81 zeros) representing no user input.
- * Used as default value for user input in solver APIs.
- */
-exports.EMPTY_BOARD = '0'.repeat(81);
-/**
- * Empty pencilmarks string (80 commas = 81 empty elements).
- * Used as default value for pencilmarks in solver APIs.
- */
-exports.EMPTY_PENCILMARKS = ','.repeat(80);
-// =============================================================================
-// Cell Notation Utilities
-// =============================================================================
-/**
- * Format a cell position in R1C1 notation (1-indexed for human readability).
- *
- * @param row - Row index (0-8)
- * @param col - Column index (0-8)
- * @returns String like "R1C1" for top-left, "R9C9" for bottom-right
- *
- * @example
- * ```typescript
- * cellName(0, 0); // "R1C1"
- * cellName(4, 4); // "R5C5"
- * cellName(8, 8); // "R9C9"
- * ```
- */
-function cellName(row, col) {
-    return `R${row + 1}C${col + 1}`;
-}
-/**
- * Format multiple cell positions as a comma-separated list in R1C1 notation.
- *
- * @param cells - Array of [row, col] pairs
- * @returns String like "R1C1, R2C3, R5C5"
- *
- * @example
- * ```typescript
- * cellList([[0, 0], [1, 2], [4, 4]]); // "R1C1, R2C3, R5C5"
- * ```
- */
-function cellList(cells) {
-    return cells.map(([row, col]) => cellName(row ?? 0, col ?? 0)).join(', ');
-}
-/**
- * Get the block index (0-8) for a given cell position.
- * Blocks are numbered left-to-right, top-to-bottom:
- * ```
- * 0 1 2
- * 3 4 5
- * 6 7 8
- * ```
- *
- * @param row - Row index (0-8)
- * @param col - Column index (0-8)
- * @returns Block index (0-8)
- *
- * @example
- * ```typescript
- * getBlockIndex(0, 0); // 0 (top-left block)
- * getBlockIndex(4, 4); // 4 (center block)
- * getBlockIndex(8, 8); // 8 (bottom-right block)
- * ```
- */
-function getBlockIndex(row, col) {
-    return Math.floor(row / exports.BLOCK_SIZE) * exports.BLOCK_SIZE + Math.floor(col / exports.BLOCK_SIZE);
-}
-/**
- * Get the block number (1-9) for a given cell position.
- * Same as getBlockIndex but 1-indexed for human readability.
- *
- * @param row - Row index (0-8)
- * @param col - Column index (0-8)
- * @returns Block number (1-9)
- */
-function getBlockNumber(row, col) {
-    return getBlockIndex(row, col) + 1;
-}
-/**
- * Convert a flat cell index (0-80) to row and column.
- *
- * @param index - Flat index (0-80)
- * @returns [row, col] tuple (both 0-8)
- *
- * @example
- * ```typescript
- * indexToRowCol(0);  // [0, 0]
- * indexToRowCol(40); // [4, 4]
- * indexToRowCol(80); // [8, 8]
- * ```
- */
-function indexToRowCol(index) {
-    return [Math.floor(index / exports.BOARD_SIZE), index % exports.BOARD_SIZE];
-}
-/**
- * Convert row and column to a flat cell index (0-80).
- *
- * @param row - Row index (0-8)
- * @param col - Column index (0-8)
- * @returns Flat index (0-80)
- *
- * @example
- * ```typescript
- * rowColToIndex(0, 0); // 0
- * rowColToIndex(4, 4); // 40
- * rowColToIndex(8, 8); // 80
- * ```
- */
-function rowColToIndex(row, col) {
-    return row * exports.BOARD_SIZE + col;
-}
-// =============================================================================
-// Time Formatting Utilities
-// =============================================================================
-/**
- * Format seconds as MM:SS or HH:MM:SS.
- *
- * @param seconds - Total seconds to format
- * @returns Formatted time string
- *
- * @example
- * ```typescript
- * formatTime(65);    // "01:05"
- * formatTime(3661);  // "01:01:01"
- * formatTime(0);     // "00:00"
- * ```
- */
-function formatTime(seconds) {
-    const hours = Math.floor(seconds / 3600);
-    const minutes = Math.floor((seconds % 3600) / 60);
-    const secs = seconds % 60;
-    if (hours > 0) {
-        return `${hours.toString().padStart(2, '0')}:${minutes.toString().padStart(2, '0')}:${secs.toString().padStart(2, '0')}`;
-    }
-    return `${minutes.toString().padStart(2, '0')}:${secs.toString().padStart(2, '0')}`;
-}
-/**
- * Parse MM:SS or HH:MM:SS time string to seconds.
- *
- * @param timeString - Time string in MM:SS or HH:MM:SS format
- * @returns Total seconds, or 0 if invalid format
- *
- * @example
- * ```typescript
- * parseTime("01:05");     // 65
- * parseTime("01:01:01");  // 3661
- * parseTime("invalid");   // 0
- * ```
- */
-function parseTime(timeString) {
-    const parts = timeString.split(':').map(p => parseInt(p, 10));
-    if (parts.some(isNaN))
-        return 0;
-    if (parts.length === 2) {
-        return (parts[0] ?? 0) * 60 + (parts[1] ?? 0);
-    }
-    else if (parts.length === 3) {
-        return (parts[0] ?? 0) * 3600 + (parts[1] ?? 0) * 60 + (parts[2] ?? 0);
-    }
-    return 0;
-}
-/**
- * Format a set of digits like {1, 2, 3} for display.
- *
- * @param digits - String or array of digits
- * @returns Formatted string like "{1, 2, 3}"
- *
- * @example
- * ```typescript
- * formatDigits("123");     // "{1, 2, 3}"
- * formatDigits([1, 2, 3]); // "{1, 2, 3}"
- * ```
- */
-function formatDigits(digits) {
-    const arr = typeof digits === 'string' ? digits.split('') : digits.map(String);
-    return `{${arr.join(', ')}}`;
-}
-// =============================================================================
-// UUID Validation Utilities
-// =============================================================================
-/** UUID regex pattern (lowercase or uppercase) */
-const UUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
-/**
- * Check if a string is a valid UUID format.
- *
- * @param id - String to validate
- * @returns true if valid UUID format
- *
- * @example
- * ```typescript
- * isValidUUID('123e4567-e89b-12d3-a456-426614174000'); // true
- * isValidUUID('not-a-uuid'); // false
- * ```
- */
-function isValidUUID(id) {
-    return UUID_PATTERN.test(id);
-}
-/**
- * Validate a UUID and throw if invalid.
- *
- * @param uuid - UUID string to validate
- * @param name - Optional name for error message (e.g., "Board UUID")
- * @returns The validated UUID string
- * @throws Error if UUID is missing or invalid format
- *
- * @example
- * ```typescript
- * const id = validateUUID(params.id, 'Board UUID'); // throws if invalid
- * ```
- */
-function validateUUID(uuid, name = 'UUID') {
-    if (!uuid) {
-        throw new Error(`${name} is required`);
-    }
-    if (!isValidUUID(uuid)) {
-        throw new Error(`Invalid ${name} format: "${uuid}". Expected UUID format (xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx)`);
-    }
-    return uuid;
-}
-// =============================================================================
-// Technique URL Utilities
-// =============================================================================
-/**
- * Get technique icon URL from technique ID.
- *
- * @param techniqueId - Technique ID number
- * @returns Icon URL path (e.g., "/technique.full.house.svg")
- *
- * @example
- * ```typescript
- * getTechniqueIconUrl(TechniqueId.FULL_HOUSE); // "/technique.full.house.svg"
- * getTechniqueIconUrl(TechniqueId.X_WING);     // "/technique.x.wing.svg"
- * getTechniqueIconUrl(TechniqueId.XY_WING);    // "/technique.xy.wing.svg"
- * ```
- */
-function getTechniqueIconUrl(techniqueId) {
-    const title = getTechniqueNameById(techniqueId);
-    const normalized = title
-        .toLowerCase()
-        .replace(/\s+/g, '.') // spaces to dots
-        .replace(/-/g, '.'); // hyphens to dots
-    return `/technique.${normalized}.svg`;
-}
-//# sourceMappingURL=index.js.map