rrrene/credo

Credo is a static analysis tool for the Elixir programming language that enforces code consistency, design principles, and safety standards. It operates via a modular execution pipeline that parses source code to detect issues related to style, refactoring, and potential bugs. The system provides a flexible CLI for running checks, generating reports in various formats, and analyzing code diffs against Git history.

25 changes.

Credo was restructured from a monolithic runner into a modular execution pipeline backed by GenServers and ETS caching to significantly improve performance and concurrency. This architectural shift introduced a new configuration format, expanded the suite of consistency, design, and refactoring checks, and modernized the CLI and test infrastructure.

22 changes.

The project refactored its core execution engine into a modular, task-based pipeline to improve state isolation and debugging capabilities. Concurrently, it expanded the CLI by introducing new commands for listing issues and explaining checks, while adding extensive support for machine-readable output formats like JSON and SARIF.

16 changes.

This period focused on expanding Credo's CLI capabilities with new commands for environment diagnostics and Git diff analysis, alongside a new consistency check for unused variable naming. Significant effort was dedicated to building a robust testing infrastructure, including a new test helper library, comprehensive integration tests for CLI commands, and extensive fixtures to support plugin development and regression testing.

The \credo explain\ command now supports a JSON output format, allowing users to consume check and issue explanations in a machine-readable structure. This is implemented via a new \Credo.CLI.Command.Explain.Output.Json\ module that formats explanations into a map, converting related code tuples to lists for serialization, alongside the existing default text-based output.

lib/credo/cli/command/categories/output, lib/credo/cli/command/explain/output · high confidence

The Info command now allows users to view detailed configuration data and output results in JSON format. When the verbose flag is enabled, the default text output includes lists of active configs, files, and checks alongside system version information, while the JSON output provides the same structured data for programmatic consumption.

lib/credo/cli/command/info/output · high confidence

A new \credo diff\ command has been added, allowing users to run Credo checks against code changes relative to a specific point in Git history. Users can specify the comparison baseline using \--from-git-ref\, \--from-git-merge-base\, \--from-dir\, or \--since\. The command filters issues to show only those that are new, fixed, or kept, and supports flags like \--show-fixed\ and \--show-kept\ to control output visibility. It also respects existing Credo options for checks, files, and formatting, and sets the exit status based on new issues found.

lib/credo/cli/command/diff · high confidence

The suggest command now supports an incremental build mode that reuses results from previous runs to speed up subsequent executions. When files have not changed, the system selectively transfers issues from the previous execution and modifies the configuration to only run necessary checks, significantly reducing analysis time for unchanged code.

lib/credo/cli/command/suggest · high confidence

Credo now supports multiple output formats (default, flycheck, oneline, json) via a new FormatDelegator, allowing users to choose the style that best fits their workflow or CI tools. The CLI also includes a new --first-run flag that displays a guided hint when a project has many issues, suggesting ways to filter or ignore them. Additionally, the final summary now reports the number of checks executed and files analyzed, and the UI layer has been refactored to use a GenServer for consistent, color-aware shell output.

lib/credo/cli/output · high confidence

Users can now generate custom Credo checks and configuration files directly from the command line. The new \gen.check\ command scaffolds a new custom check file based on a provided filename, while \gen.config\ initializes a new \.credo.exs\ configuration file in the current directory. Additionally, the \help\ command now displays a formatted banner with a list of available commands and their descriptions, and the \version\ command supports JSON output formatting via the \--format\ switch.

lib/credo/cli/command · high confidence

The \credo explain\ command is now available to provide detailed explanations for specific code checks or issues. Users can pass a check name (e.g., \Credo.Check.Refactor.Nesting\) to see its category, priority, and explanation, or provide a file location with line and column numbers (e.g., \lib/foo/bar.ex:13:6\) to see why a specific issue was flagged at that spot. The command supports multiple output formats, including JSON, and includes validation to ensure the provided file path is within the working directory.

lib/credo/cli/command/explain · high confidence

A new \credo list\ command has been added, allowing users to view all detected issues organized by source file. The command supports multiple output formats including JSON, Flycheck, Oneline, and SARIF, and provides filtering options such as \--checks\, \--files-included\, \--files-excluded\, and \--min-priority\ to tailor the report.

lib/credo/cli/command/list · high confidence

A new \mix credo info\ command has been added to display useful debug information about the Credo environment. It reports system details (Credo, Elixir, and Erlang versions), lists loaded configuration files (including those from plugins), shows active checks and their parameters, and lists the source files being analyzed. The output supports multiple formats, including JSON and a default human-readable view, and can be filtered using options like \--verbose\ to include checked files.

lib/credo/cli/command/info · high confidence

This update introduces a comprehensive suite of new refactoring checks and updates existing ones to improve code quality and performance. New checks include ABCSize (complexity metric), AppendSingleItem (list concatenation), Apply (direct function calls), CaseTrivialMatches (deprecated), CondInsteadOfIfElse, CondStatements, CyclomaticComplexity, DoubleBooleanNegation, FilterCount, FilterFilter, FilterReject, FunctionArity, IoPuts, LongQuoteBlocks, MapInto (Elixir \< 1.8 only), MapJoin, MapMap, MatchInCondition, ModuleDependencies, NegatedConditionsInUnless, NegatedConditionsWithElse, and NegatedIsNil. These checks provide specific suggestions for refactoring, such as using \Enum.count/2\ instead of \Enum.filter/2 \|\> Enum.count/1\, preferring direct function calls over \apply/2\ and \apply/3\, and avoiding double boolean negations. Existing checks have also been updated with better triggers, false positive fixes, and improved documentation.

lib/credo/check/refactor · high confidence

Credo now includes a new consistency check that enforces naming conventions for unused variables. The implementation traverses the AST to identify unused variables in function definitions, macros, test contexts, and pattern matches, distinguishing between anonymous variables (starting with \\_\) and meaningful unused variables. It reports violations where naming conventions are not followed, helping maintain consistent code style across the project.

_lib/credo/check/consistency/unused\_variable\names · high confidence

Credo now includes a suite of new consistency checks (EX1001–EX1008) to enforce uniform coding styles across your codebase. These checks cover exception naming suffixes/prefixes, line endings (Unix vs. Windows), indentation (tabs vs. spaces), spacing around operators and parentheses, unused variable naming conventions, parameter pattern matching styles, and the use of multi-alias/import/require/use directives. Each check identifies the most common style in your codebase and flags deviations, helping maintain a consistent look and feel without impacting code correctness.

lib/credo/check/consistency · high confidence

This release introduces several new checks in the \lib/credo/check/design\ directory to improve code structure and configuration management. The \AliasUsage\ check (EX2001) encourages using aliases for non-top-level modules, with configurable thresholds for nesting depth, call frequency, and struct literals. The \DuplicatedCode\ check (EX2002) identifies copy-pasted code blocks across files, using configurable mass and node thresholds. Configuration hygiene is addressed by \DeprecatedChecksConfig\ (EX2008), which warns against the old list-based check configuration format, and \MissingCheckInConfig\ (EX2007), which flags checks that are neither explicitly enabled nor disabled in the config. Additionally, \RedundantConfigComments\ (EX2006) detects \\# credo:\ comments that no longer suppress any issues, and \SkipTestWithoutComment\ (EX2003) ensures skipped tests are documented with a preceding comment. Tag checks (\TagFIXME\, \TagTODO\) are also updated to use the new \TagHelper\ for finding tags in comments and doc attributes.

lib/credo/check/design · high confidence

The \diff\ command now supports additional output formats beyond the default terminal view. Users can generate machine-readable JSON output (categorizing issues as new, fixed, or old) via the new \Json\ formatter, concise single-line reports via the \Oneline\ formatter, and IDE-compatible \Flycheck\ format. These modules provide alternative ways to consume the diff analysis results, complementing the existing colored terminal output.

lib/credo/cli/command/diff/output · high confidence

Users can now generate new custom checks and configuration files via the new \mix credo.gen.check\ and \mix credo.gen.config\ tasks. The main \mix credo\ task has been updated to require the \loadpaths\ application before running, ensuring dependencies are loaded, and its help text has been simplified to direct users to \--help\ for options.

lib/mix · high confidence

The Suggest command now supports additional output formats via the --format flag, including SARIF, JSON, JSONL, Flycheck, and Oneline. These new modules allow users to integrate Credo results into CI/CD pipelines, IDEs, or other tooling that requires structured or machine-readable data, alongside the existing default and short human-readable outputs.

lib/credo/cli/command/list/output, lib/credo/cli/command/suggest/output · high confidence

Users can now choose from additional output formats for Credo issues via the CLI. The new Flycheck formatter provides a standard error-reporting format compatible with many editors. A new JSON formatter outputs structured issue data, utilizing the Jason library for encoding and including details like check name, category, filename, line/column numbers, and trigger text. The Oneline formatter offers a compact, sorted single-line-per-issue view with color-coded priority and check tags. Finally, SARIF support allows users to generate Static Analysis Results Interchange Format reports, mapping Credo priorities to SARIF levels and ranks, and including rule definitions and file locations for integration with security and CI tools.

lib/credo/cli/output/formatter · high confidence

This update introduces a suite of new static analysis checks in the \lib/credo/check/warning\ directory to catch common pitfalls and potential security issues. It adds checks for unsafe runtime atom creation (\UnsafeToAtom\), command injection via shell execution (\UnsafeExec\), and environment variable leakage when spawning processes (\LeakyEnvironment\). It also flags debugging artifacts like \dbg/1\ and \IEx.pry/0\ calls, warns against using \Mix.env\ in application code, and detects expensive or redundant operations such as \Enum.count\ for emptiness checks or boolean operations on identical values. Additional checks cover unsafe \Map.get\ usage in pipes, missing logger metadata keys, and the use of structs in specs.

lib/credo/check/warning · high confidence

The \config/config.exs\ file has been deleted, removing the previous application configuration settings that were defined there.

config · high confidence

The internal implementation of the \credo diff\ command has been restructured from a monolithic task into a series of dedicated, modular tasks (e.g., \FilterIssues\, \GetGitDiff\, \PrintResultsAndSummary\). This change improves code maintainability and separation of concerns within the diff command's execution pipeline, allowing for clearer handling of git reference resolution, issue filtering (new/old/fixed), and output generation without altering the external CLI interface or user-facing behavior.

lib/credo/cli/command/diff/task · high confidence

A change to existing behaviour in lib/credo/check/readability — 395 commits (129 fixs), 38 files.

lib/credo/check/readability · medium confidence · unverified

The categories command now supports a JSON output format. Users can request machine-readable output by setting the format configuration to 'json', which switches the output from the default human-readable text to a structured JSON representation of the issue categories.

lib/credo/cli/command/categories · high confidence

This release ensures compatibility with Elixir 1.20.0 and updates the development environment to Erlang 29.0 and Elixir 1.20.2. It introduces a comprehensive default configuration file (\.credo.exs\) that replaces the legacy JSON format, enabling a wide range of checks for consistency, design, readability, refactoring, and warnings out of the box. The project also migrates its CI infrastructure from Travis CI to GitHub Actions and updates the code formatter to use a 120-character line length.

(repo-wide) · high confidence

Credo has been restructured from a monolithic configuration and run model into a modular execution pipeline. The core \Credo.Config\ module (which previously handled JSON-based rule loading) has been replaced by \Credo.Execution\, \Credo.ConfigFile\, and \Credo.ConfigBuilder\, which manage a new \.credo.exs\ configuration format and CLI options. The analysis process is now driven by a pipeline of tasks defined in \Credo.Execution\, allowing plugins to hook into specific stages via \Credo.Plugin\. Internally, heavy data like ASTs, tokens, and lines are offloaded to individual GenServers (e.g., \Credo.Service.SourceFileAST\) for concurrent access, and the \Credo.SourceFile\ struct has been simplified to store only metadata (filename, hash, status) while retrieving data from these services. A new \Credo.Watcher\ module enables file-watching mode, and the \Credo.Application\ module starts the necessary supervisors and services.

lib/credo · high confidence

The consistency check for multi-alias, import, require, and use directives now uses a dedicated collector to more accurately identify violations. This change refines how the tool groups and counts usages of these directives, reducing false positives and ensuring that inconsistencies in how modules are aliased or imported are reported correctly across the codebase.

_lib/credo/check/consistency/multi\_alias\_import\_require\use · high confidence

The LineEndings consistency check has been refactored to include the specific line number where a line ending mismatch occurs. Previously, the check might have only reported that an inconsistency existed; now, users will see exactly which line in the source file deviates from the expected line ending style (Unix vs. Windows), making it easier to locate and fix the issue.

_lib/credo/check/consistency/line\endings · high confidence

The CLI execution flow is now structured into four distinct tasks: \LoadAndValidateSourceFiles\ handles loading source files and reports invalid or timed-out files; \PrepareChecksToRun\ processes config comments, enables disabled checks if the \--enable-disabled-checks\ flag is set, excludes low-priority checks, and filters checks based on the current Elixir version; \RunChecks\ executes the prepared checks using the \Runner\; and \SetRelevantIssues\ filters the resulting issues for importance and validity, then sorts them by check ID, filename, and line number before storing them in the execution context.

lib/credo/cli/task · high confidence

Credo now caches expensive source-file computations—including tokenization, AST parsing, line extraction, and scope analysis—in public ETS tables. This change eliminates serialization bottlenecks by allowing concurrent check processes to read and write directly to ETS without routing through a GenServer, significantly speeding up check execution for large codebases.

lib/credo/service · high confidence

The consistency checks for exception names and parameter pattern matching have been refactored to use new, dedicated Collector modules. This change extracts the AST traversal and data collection logic into separate components, reducing boilerplate and improving the maintainability of how Credo identifies inconsistencies in code style.

_lib/credo/check/consistency/exception\names · high confidence

The execution engine now manages config files, source files, issues, and timing data via dedicated GenServer processes instead of storing them directly in the Execution struct, improving state isolation. A new Task pipeline system allows checks to run as composable steps with support for halting and error handling, while a new Timing API provides detailed span and event tracking for debugging execution performance.

lib/credo/execution · high confidence

The command-line interface has been restructured to use a new \Credo.CLI.Command\ behavior for defining commands and a dedicated \Credo.CLI.Options\ module for parsing arguments, replacing the previous ad-hoc parsing logic. This change introduces a \Credo.CLI.Switch\ struct to standardize switch definitions and adds support for the \--min-priority\ switch, allowing users to filter results by priority name or integer. Additionally, the \Credo.CLI.Filename\ module now correctly handles Windows-style paths (e.g., \C:/path\) when extracting line and column numbers, fixing previous bugs where Windows paths were misinterpreted. The \Credo.CLI.Output\ module has been updated to display refactor checks with the tag \\[F\]\ instead of \\[R\]\ and provides new helper functions for priority arrows and names.

lib/credo/cli · high confidence

The \SpaceAroundOperators\ consistency check has been refactored to use a new \Collector\ module for token traversal and a \SpaceHelper\ module for logic. This change introduces specific handling to ignore the pipe operator (\\|\>\) and correctly skip function captures, binary patterns, and \@module\_attrs\ (such as \@spec\ and \@type\) to prevent false positives. It also adds logic to handle unary minus in specific contexts (e.g., after \^\ or within parentheses) and ensures float tokens are interpreted correctly, improving the accuracy of space-around-operator validations.

_lib/credo/check/consistency/space\_around\operators · high confidence

The check runner has been restructured to use a new \Credo.Execution\ context and a parallelized \Task.async\_stream\ approach, improving performance and stability. A new \Credo.Check.ConfigComment\ module now parses \\# credo:disable...\ comments, supporting regex patterns for check names to allow more flexible exclusions. Additionally, \Credo.Check.Params\ centralizes parameter resolution, ensuring backward compatibility with older keyword-based configurations while introducing support for new built-in parameters like \:tags\ and \:files\.

lib/credo/check · high confidence

The \lib/credo/code\ directory has been reorganized into a set of focused helper modules to improve maintainability and performance. New modules include \Credo.Code.Block\ for analyzing control flow blocks, \Credo.Code.Token\ and \Credo.Code.TokenAstCorrelation\ for precise token position tracking and AST correlation, and \Credo.Code.InterpolationHelper\ for handling string interpolations. String, charlist, sigil, and heredoc parsing logic has been extracted into \Credo.Code.Strings\, \Credo.Code.Charlists\, \Credo.Code.Sigils\, and \Credo.Code.Heredocs\ respectively, while module and scope analysis is now handled by \Credo.Code.Module\ and \Credo.Code.Scope\. This refactoring supports faster checks by avoiding intermediate binary construction and ensures compatibility with newer Elixir versions.

lib/credo/code · high confidence

The library's internal execution model has been significantly restructured. The legacy \Credo.Rule.Runner\ module, which handled rule execution and formatting callbacks, has been removed. In its place, the main \Credo.run/1\ entry point now delegates to a new \Credo.Execution\ pipeline, introducing structured execution contexts, timing spans, and debug report generation. This change alters the internal flow of analysis, moving from a direct callback-based approach to a more modular execution struct, while also exposing a new \run/2\ function for incremental builds based on changed files.

lib · high confidence

The Credo execution engine has been restructured from a monolithic process into a series of distinct, composable tasks located in the execution task directory. This change introduces specific modules for handling configuration (loading defaults, extra configs via the CREDO\_EXTRA\_CONFIG environment variable, and validation with warnings for empty patterns or invalid parameters), command initialization (parsing CLI options, determining the command, and initializing plugins), and output generation (writing HTML debug reports with detailed timing data). Users benefit from more robust error handling during config loading, clearer warnings for misconfigured checks, and enhanced debugging capabilities through structured timing logs.

lib/credo/execution/task · high confidence

The SpaceInParentheses consistency check has been refactored to use a new token-based collector instead of previous string or regex-based methods. This change improves the detection of spacing issues around parentheses, brackets, and maps, specifically addressing false positives that occurred with empty enums and single-line strings. Users will see more accurate linting results that correctly handle edge cases in Elixir code formatting.

_lib/credo/check/consistency/space\_in\parentheses · high confidence

Added housekeeping and coverage tests for Credo checks; Added integration test fixture for bare Git repositories; Added integration test fixtures for Credo and SARIF configurations; Added integration test suite for Credo CLI commands; Added integration tests for Credo plugin development; Added regression test for issue \#1235 (trailing whitespace); Added test coverage for CLI filename parsing, options, and sorter; Added test coverage for CLI output components; Added test coverage for Readability checks; Added test fixtures for CLI options; Added test fixtures for Credo check plugin configuration; Added test fixtures for Credo file exclusion; Added test fixtures for static analysis regression testing; Added test helpers and assertions for Credo checks; Added tests for Credo.Code AST analysis helpers; Added tests for GenCheck command name generation; Added tests for JSON formatter sanitization; Added tests for the MultiAliasImportRequireUse collector; Added tests for the ParameterPatternMatching consistency check collector; Added tests for the SpaceAroundOperators collector; Added tests for the SpaceInParentheses consistency collector; Expanded test coverage for Credo core components; Expanded test coverage for warning checks; New regression testing and smoke test infrastructure; New test helper library for validating Credo checks.

This release updates the Credo static analysis tool to version 1.8.0-dev, raising the minimum supported Elixir version to 1.13.0. The dependency tree has been significantly modernized: the legacy \poison\ JSON library and \dogma\ linter have been removed, replaced by \jason\ (1.4.4) for JSON handling and \credo\_tokenizer\ (0.2.7) for parsing. Additional development dependencies include \ex\_doc\ (0.40.3) for documentation generation, \inch\_ex\ (2.1.0) for code coverage metrics, and \mix\_test\_watch\ (1.4.0) for automated test running. The \bunt\ library has been updated to 1.0.0, and \file\_system\ to 1.1.0. The project now explicitly registers \Credo.Application\ as the application module and configures test coverage via ExCoveralls.

(dependencies) · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• CAI 60 → 65 (+4.5)
• Rubric changed (rubric-2026.08.19 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 96 → 96 (-0.8)
• Architecture 99 → 99 (+0.5)
• Maturity 55 → 55 (+0.1)
• Readiness 64 → 80 (+15.6)
• Security 67 → 99 (+31.9)
• Accessibility 56 → 56 (+0.0)

• Coverage not included — suite not readable by the collector
• Dependency hygiene not measured — no supported dependency manifest was read
• Duplicated block (10 lines × 2) (lib/credo/cli/command/diff/output/default.ex)
• Duplicated block (10 lines × 2) (lib/credo/cli/output/formatter/sarif.ex)
• Duplicated block (11 lines × 2) (lib/credo/execution/task/write_debug_report.ex)
• Duplicated block (12 lines × 2) (lib/credo/check/readability/nested_function_calls.ex)
• Duplicated block (12 lines × 2) (lib/credo/config_file.ex)
• Duplicated block (13 lines × 2) (lib/credo/code/strings.ex)
• Duplicated block (14 lines × 2) (lib/credo/cli/command/diff/diff_summary.ex)
• Duplicated block (15 lines × 2) (lib/credo/cli/command/diff/output/default.ex)
• Duplicated block (16 lines × 2) (lib/credo/cli/command/categories/output/default.ex)
• Duplicated block (16 lines × 2) (lib/credo/cli/command/explain/output/default.ex)
• Duplicated block (20 lines × 2) (lib/credo/code/interpolation_helper.ex)
• Duplicated block (22 lines × 2) (lib/credo/cli/command/explain/output/default.ex)
• Duplicated block (24 lines × 2) (lib/credo/cli/command/diff/diff_summary.ex)
• Duplicated block (24 lines × 2) (lib/credo/cli/command/diff/output/default.ex)
• Duplicated block (9 lines × 4) (lib/credo/cli/command/diff/diff_output.ex)
• FileTooLong: code/strings.ex (lib/credo/code/strings.ex)
• High: security finding (details withheld)
• High: security finding (details withheld)
• …and 32 more

• Documentation: no contributor guidance (README.md)
• Documentation: no installation or build instructions (README.md)
• Documentation: no usage examples (README.md)
• Duplicated block (11 lines × 2) (lib/credo/execution/task/write_debug_report.ex)
• Duplicated block (12 lines × 2) (lib/credo/check/readability/nested_function_calls.ex)
• Duplicated block (12 lines × 2) (lib/credo/cli/command/diff/output/default.ex)
• Duplicated block (13 lines × 2) (lib/credo/code/strings.ex)
• Duplicated block (13 lines × 2) (lib/credo/config_file.ex)
• Duplicated block (13–14 lines × 2) (lib/credo/cli/output/formatter/sarif.ex)
• Duplicated block (14 lines × 2) (lib/credo/check/design/tag_fixme.ex)
• Duplicated block (14 lines × 2) (lib/credo/cli/command/diff/output/default.ex)
• Duplicated block (16 lines × 3) (lib/credo/cli/command/categories/output/default.ex)
• Duplicated block (18 lines × 2) (lib/credo/cli/command/categories/output/default.ex)
• Duplicated block (18 lines × 2) (lib/credo/cli/command/diff/diff_summary.ex)
• Duplicated block (19 lines × 2) (lib/credo/check/readability/unnecessary_alias_expansion.ex)
• Duplicated block (19 lines × 2) (lib/credo/cli/command/explain/output/default.ex)
• Duplicated block (19 lines × 5) (lib/credo/check/readability/unnecessary_alias_expansion.ex)
• Duplicated block (20 lines × 2) (lib/credo/check/readability/capture_operator.ex)
• Duplicated block (20 lines × 4) (lib/credo/check/readability/pipe_into_anonymous_functions.ex)
• Duplicated block (21 lines × 4) (lib/credo/check/readability/prefer_implicit_try.ex)
• …and 117 more

• 13 commits — 8 feature/other, 5 fixes

• lib/credo — 7 commits
• (repo) — 5 commits
• (root) — 1 commit

• fix: Fix custom check tutorial sample and doc typos
• fix: Merge pull request #1304 from superhawk610/fix/struct-literal-alias-usage
• fix: Merge pull request #1310 from woylie/fix/non-boolean-async-value
• fix: fix(alias_usage): flag unaliased struct literals
• fix: fix: handle async option set to a non-boolean value
• change: Add markdown formatter to docs output
• change: Merge pull request #1308 from oliver-kriska/docs-markdown-formatter
• change: Merge pull request #1314 from Jump-App/ty/tokenization-cache
• change: Merge pull request #1315 from toyeshhm/fix-doc-typos
• change: Remove comment
• change: add include_struct_literals option
• change: perf (tokenization): Speed up token-based checks by caching file tokenization
• change: refactor: Add get_or_compute/2 wrapper to ETSTableHelper

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

rrrene/credo was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.