update/readme

Updated readme and file header templates.

Author: MrMatthewLayton

OnixLabs.Core.UnitTests.Data/Mutable.cs

@@ -1,4 +1,4 @@
-// Copyright 2020-2025 ONIXLabs
+// Copyright 2020 ONIXLabs
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.

OnixLabs.Numerics.UnitTests.Data/TestDataAttribute.cs

@@ -1,4 +1,4 @@
-// Copyright 2020-2025 ONIXLabs
+// Copyright 2020 ONIXLabs
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.

OnixLabs.Numerics.UnitTests/GenericMathPow10Tests.cs

@@ -1,4 +1,4 @@
-// Copyright 2020-2025 ONIXLabs
+// Copyright 2020 ONIXLabs
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.

README.md

@@ -2,116 +2,91 @@
 
 # ONIXLabs .NET Library
 
-The world of software development is ever-evolving, driven by the constant need for innovation, efficiency, and maintainability. In this landscape, libraries and frameworks play a crucial role in simplifying complex tasks, promoting code reuse, and fostering community collaboration. The ONIXLabs .NET Library is born out of this very ethos—a desire to create a robust, versatile, and community-friendly library that fills the gaps often encountered in various development projects.
+[![NET](https://github.com/onix-labs/onixlabs-dotnet/actions/workflows/dotnet.yml/badge.svg)](https://github.com/onix-labs/onixlabs-dotnet/actions/workflows/dotnet.yml)
 
-[![.NET](https://github.com/onix-labs/onixlabs-dotnet/actions/workflows/dotnet.yml/badge.svg)](https://github.com/onix-labs/onixlabs-dotnet/actions/workflows/dotnet.yml)
+The ONIXLabs .NET Library is a suite of general-purpose, production-ready libraries designed to support modern application development with a strong emphasis on correctness, composability, and value semantics. They are designed to integrate cleanly into both small utilities and large-scale systems, without imposing architectural constraints or framework lock-in.
 
-## ONIXLabs Core
+At a high level, ONIXLabs provides:
 
-At the heart of the ONIXLabs .NET Library lies the Core module, serving as the bedrock for building resilient and scalable applications. Here, developers will find essential APIs and interfaces meticulously designed to promote code reusability, maintainability, and readability. From foundational interfaces to extension methods enriching object manipulation, ONIXLabs Core sets the stage for seamless development experiences.
+-   Foundational primitives and patterns missing or underrepresented in the BCL
+-   Functional and value-oriented abstractions for safer code
+-   High-precision numeric and generic math utilities
+-   Security and cryptography APIs with strong typing and value semantics
+-   Infrastructure helpers that reduce boilerplate while preserving clarity
 
-### Interfaces
+Current .NET Support includes .NET 8.0, 9.0 and 10.0, and all packages are published to [Nuget](https://www.nuget.org/packages?q=onixlabs).
 
-The ONIXLabs .NET Library includes interfaces such as `IValueEquatable<T>`, `IValueComparable<T>`, and `IBinaryConvertible`, providing a foundation for implementing common patterns and functionalities.
+## Package Overview
 
-### Extension Methods
+-   **OnixLabs.Core** – Foundational primitives, patterns, and extensions
+-   **OnixLabs.DependencyInjection** – Configuration-driven DI registration
+-   **OnixLabs.Numerics** – Arbitrary-precision numbers and generic math
+-   **OnixLabs.Security** – Non-cryptographic security utilities
+-   **OnixLabs.Security.Cryptography** – Cryptographic primitives and structures
 
-The ONIXLabs .NET Library extends the capabilities of objects, arrays, strings, sequences, comparables, and enumerables, making data manipulation more intuitive and efficient.
+## OnixLabs.Core
 
-### Preconditions
+[See it on Nuget](https://www.nuget.org/packages/OnixLabs.Core)
 
-The ONIXLabs .NET Library offers a comprehensive set of preconditions designed to facilitate clean, consistent, and reliable guard clauses. This promotes a "fail-fast" programming approach, ensuring that potential issues are identified and addressed early in the execution process.
+Foundational primitives, patterns, and extensions that address common gaps in the .NET Base Class Library. This package provides low-level building blocks used throughout the ONIXLabs ecosystem, but is also useful as a standalone utility library in any .NET application.
 
-### Strong Enumeration Pattern
+-   Strongly typed enumeration pattern (`Enumeration<T>`)
+-   Functional patterns (`Optional<T>`, `Result`, `Result<T>`)
+-   Preconditions and guard clause utilities
+-   Specification pattern with LINQ-compatible expressions (`Specification<T>`)
+-   Value semantics interfaces (`IValueEquatable<T>`, `IValueComparable<T>`)
+-   Binary conversion abstractions (`IBinaryConvertible`, span- and memory-based variants)
+-   Collection generators with LINQ-style query support
+-   Extension methods for arrays, objects, strings, comparables, random, and more
+-   Extensions for `IEnumerable`, `IEnumerable<T>`, and `IQueryable<T>`
+-   Reflection helpers for `Type`
+-   Strongly typed `Base16`, `Base32`, `Base58`, and `Base64` text types
+-   Extensions for `StringBuilder` and `Encoding`
 
-The ONIXLabs .NET Library provides an abstraction of the strong enumeration pattern, allowing consumers to build strict, strongly typed enumerations which can be extended with value and associated behavior.
+## OnixLabs.DependencyInjection
 
-### Functional Concepts
+[See it on Nuget](https://www.nuget.org/packages/OnixLabs.DependencyInjection)
 
-The ONIXLabs .NET Library includes robust implementations of the `Result`, `Result<T>`, and `Optional<T>` patterns, which are widely used in functional programming languages. These implementations address two prevalent challenges in object-oriented programming: exception handling and null reference management. By integrating these patterns, the library provides more predictable and maintainable code structures.
+Lightweight extensions for Microsoft’s dependency injection abstractions, focused on reducing boilerplate and improving configurability of service registration.
 
-#### Result Pattern
+-   `IServiceCollection` extensions
+-   Configuration-driven service lifetime selection
+-   Cleaner, more consistent registration APIs
 
-Enables methods to return a success or failure state, encapsulating both the outcome and the associated data or error message. This approach simplifies error handling and improves code readability.
+## OnixLabs.Numerics
 
-#### Optional Pattern
+[See it on Nuget](https://www.nuget.org/packages/OnixLabs.Numerics)
 
-Facilitates the handling of potentially null values, thereby reducing the risk of `NullReferenceException` and promoting safer code practices.
+High-precision numeric types and generic math utilities for scenarios where built-in numeric types are insufficient. This package emphasizes correctness, precision, and introspection of numeric values.
 
-#### Asynchronous Programming
+-   Arbitrary-precision `BigDecimal` based on generic math (`IFloatingPoint<T>`)
+-   `NumberInfo` for dissecting rational numbers into constituent parts
+-   Generic numeric abstractions (`IBaseNumber<T>`, `INumber<T>`)
+-   Extension methods for `Decimal`, `BigDecimal`, `BigInteger`, and other numeric types
 
-The ONIXLabs .NET Library extends these patterns with asynchronous programming support, including extension methods that allow `Result`, `Result<T>`, and `Optional<T>` to be seamlessly integrated into asynchronous workflows. This makes it easier to work with these patterns in modern, async-based applications, ensuring consistent and reliable error and null handling across synchronous and asynchronous contexts.
+## OnixLabs.Security
 
-### LINQ Extension Methods
+[See it on Nuget](https://www.nuget.org/packages/OnixLabs.Security)
 
-The ONIXLabs .NET Library enhances the standard LINQ capabilities with additional extension methods for working with `IEnumerable` and `IEnumerable<T>`, making it easier to perform complex queries and manipulations on collections.
+Non-cryptographic security utilities focused on safe generation and handling of security-related values.
 
-### Text Encoding Services
+-   `SecurityToken` generation
+-   Support for pseudo-random and cryptographically secure RNGs
+-   Configurable token alphabets (upper, lower, numeric, special characters)
 
-The ONIXLabs .NET Library provides codecs for various encoding schemes like `Base16`, `Base32`, `Base58`, and `Base64`, along with primitive structs representing these bases for semantic clarity.
+## OnixLabs.Security.Cryptography
 
-## ONIXLabs Numerics
+[See it on Nuget](https://www.nuget.org/packages/OnixLabs.Security.Cryptography)
 
-Numerical computations are a fundamental aspect of many software applications, often requiring precision, flexibility, and performance. The ONIXLabs .NET Library Numerics module equips developers with a suite of tools tailored to meet these demands. Whether it's obtaining detailed insights into numeric values or performing complex arithmetic operations, this module empowers developers to tackle numerical challenges with ease and confidence.
+Strongly typed cryptographic primitives and structures with value semantics, designed to make cryptographic operations safer and more explicit.
 
-### Number Information
-
-The ONIXLabs .NET Library includes a versatile struct called `NumberInfo` that provides detailed insights into any numeric value, including unscaled value, scale, significand, exponent, precision, and sign.
-
-### Number Information Formatting
-
-The ONIXLabs .NET Library features a comprehensive number formatting API that allows any number type convertible to `NumberInfo` to be formatted using various number styles. These styles include currency, decimal, exponential (scientific), fixed, general, number, and percentage formats. Additionally, the API supports automatic cultural formatting, ensuring that numbers are appropriately formatted according to different cultural conventions.
-
-### Big Decimal
-
-The ONIXLabs .NET Library provides an arbitrary-length `BigDecimal` number representation leveraging .NET's generic math interfaces. It supports a comprehensive range of arithmetic operations, parsing, conversion, and culture-specific formatting, facilitating precise numerical calculations.
-
-### Generic Math Extension Methods
-
-The ONIXLabs .NET Library extends the functionality of numerical types with useful generic math extension methods, enhancing flexibility and productivity in numerical computing tasks.
-
-## ONIXLabs Security
-
-The Security module in the ONIXLabs .NET Library focuses on non-cryptographic security measures, addressing various aspects of application security beyond encryption. This module provides tools and utilities to enhance the security of applications through mechanisms such as secure data handling, input validation, and access control. By implementing best practices and standards for secure coding, the Security module helps developers protect their applications from common vulnerabilities and threats, ensuring robust and reliable security across different components of the software.
-
-### Security Tokens
-
-The ONIXLabs .NET Library includes a powerful API for generating security tokens. These tokens are customizable sequences of random characters designed to function as temporary passwords or authentication codes. The API offers extensive configuration options, allowing developers to specify the length, character set, and complexity of the generated tokens to meet various security requirements. This flexibility ensures that the tokens can be tailored to different use cases, such as user verification, session management, or one-time password generation, thereby enhancing the security and usability of applications.
-
-## ONIXLabs Cryptography
-
-In an era marked by increasing cybersecurity threats, robust cryptographic implementations are paramount. The ONIXLabs Cryptography module offers developers a comprehensive set of APIs for handling cryptographic operations securely. From digital signatures and hash functions to Merkle trees and FIPS-202 compliant SHA3 implementations, developers can leverage ONIXLabs Cryptography to safeguard sensitive data and ensure the integrity and confidentiality of their applications.
-
-### Public/Private Key Cryptography
-
-The ONIXLabs .NET Library offers comprehensive support for public/private key cryptography, essential for secure communication and data encryption. The library includes abstractions such as `PublicKey` and `PrivateKey`, which encapsulate the raw byte data of cryptographic keys, providing a structured and secure way to handle key material. Additionally, the `NamedPublicKey` and `NamedPrivateKey` classes extend these abstractions by associating the keys with the name of the cryptographic algorithm used, enhancing clarity and ease of use in multi-algorithm contexts.
-
-The library supports various cryptographic algorithms through interfaces and concrete implementations, including ECDSA (Elliptic Curve Digital Signature Algorithm), ECDH (Elliptic Curve Diffie-Hellman), and RSA (Rivest-Shamir-Adleman). These implementations enable secure key generation, digital signing, encryption, and decryption operations. For instance, ECDSA and RSA are used for generating and verifying digital signatures, ensuring data integrity and authenticity, while ECDH facilitates secure key exchange mechanisms.
-
-By providing these abstractions and implementations, the ONIXLabs .NET Library ensures that developers can seamlessly integrate robust cryptographic functionality into their applications, leveraging the strengths of various cryptographic algorithms to meet diverse security requirements. This makes the library an invaluable tool for building secure, reliable, and high-performance applications in the .NET ecosystem.
-
-### Digital Signatures
-
-The ONIXLabs .NET Library provides several APIs for creating, storing, and verifying cryptographic digital signatures. The `DigitalSignature` struct is designed to encapsulate the underlying raw byte data of a cryptographic digital signature, ensuring the integrity and authenticity of digital messages, whilst the `DigitalSignatureAndPublicKey` struct combines a `DigitalSignature` with its corresponding `NamedPublicKey`, which is used to verify the authenticity of the digital signature.
-
-### Hashing
-
-The ONIXLabs .NET Library features a comprehensive set of APIs dedicated to creating and storing cryptographic hash values. At the core of these APIs is the `Hash` struct, which is designed to encapsulate the raw byte data of a cryptographic hash. This struct provides a robust and efficient way to handle hash values, ensuring data integrity and security across various applications.
-
-In addition to basic hashing capabilities, the ONIXLabs .NET Library includes a fully managed implementation of the FIPS-202 standardized SHA3 algorithm. This implementation covers all major variants of SHA3, including SHA3-224, SHA3-256, SHA3-384, and SHA3-512, as well as the extendable-output functions SHAKE128 and SHAKE256. By adhering to the FIPS-202 standards, the library ensures compliance with cryptographic standards.
-
-### Merkle Trees
-
-The ONIXLabs .NET Library includes implementations of the `MerkleTree` and `MerkleTree<T>`, which are essential for constructing and managing Merkle trees. A Merkle tree is a cryptographic data structure that allows efficient and secure verification of the contents of large data sets. The `MerkleTree` class provides a general implementation, while `MerkleTree<T>` offers a generic version, where `T` implements `IHashable`. These implementations support the creation of Merkle trees by recursively hashing pairs of nodes until a single root hash, known as the Merkle root, is obtained. This root hash can then be used to verify the integrity and consistency of the entire data set with minimal computational overhead. The library's implementation ensures compatibility with various hash functions, making it a versatile tool for applications requiring secure data verification, such as blockchain or distributed ledger technologies, file integrity checks, and distributed systems.
-
-### Salts
-
-The ONIXLabs .NET Library includes a `Salt` struct designed to encapsulate cryptographically secure random numbers, which are essential for various security operations. Salts are random data added to passwords or other data before hashing to ensure that identical inputs produce unique hash values. This approach prevents attackers from using precomputed tables, such as rainbow tables, to reverse-engineer hashed data. The `Salt` struct in ONIXLabs provides a simple yet powerful way to generate and manage these cryptographic salts, ensuring they are sufficiently random and secure. By incorporating salts into hashing and encryption workflows, the library significantly enhances security, making it more resistant to attacks and ensuring the robustness of applications against potential vulnerabilities. This struct is particularly useful in scenarios like password storage, token generation, and any application requiring enhanced cryptographic security.
-
-### Secrets
-
-The ONIXLabs .NET Library includes a `Secret` struct, designed to securely handle sensitive data such as passwords, encryption keys, and other confidential information. The `Secret` struct ensures that sensitive data is managed with the highest level of security by leveraging secure memory management techniques to minimize the risk of exposure. It provides methods for securely storing, accessing, and disposing of sensitive information, ensuring that data is encrypted in memory and cleared immediately after use. This approach prevents unauthorized access and reduces the risk of memory-based attacks. The `Secret` struct is particularly valuable in applications that require stringent security measures, such as authentication systems, encryption services, and any scenario where sensitive data must be protected. By incorporating the `Secret` struct, the ONIXLabs .NET Library helps developers build more secure applications, safeguarding critical information against potential breaches and ensuring compliance with security best practices.
-
-### In-Memory Encryption
-
-The ONIXLabs .NET Library ensures the highest level of security for sensitive data by implementing in-memory encryption for `Secret` and `PrivateKey` data. This technique encrypts these critical pieces of information while they are stored in memory, thereby protecting them from memory dump attacks, unauthorized access, and other forms of in-memory exploitation. By encrypting sensitive data in memory, the library reduces the risk of exposure even if an attacker gains access to the system's memory. This approach is particularly effective in defending against certain classes of attacks, such as those that exploit vulnerabilities to read memory content directly. The encrypted memory handling for `Secret` and `PrivateKey` data is a key feature that enhances the overall security posture of applications using the ONIXLabs .NET Library, ensuring that sensitive information remains confidential and secure throughout its lifecycle.
+-   Public and private key abstractions (`PublicKey`, `PrivateKey`)
+-   ECDH, ECDSA, and RSA key implementations
+-   Digital signature types (`DigitalSignature`, `DigitalSignatureAndPublicKey`)
+-   Cryptographic hash value types (`Hash`, `NamedHash`)
+-   Extensions for `HashAlgorithm`
+-   Fully managed FIPS-202 SHA-3 implementation (SHA3-224/256/384/512, SHAKE128/256)
+-   Merkle tree implementations (`MerkleTree`, `MerkleTree<T>`)
+-   Cryptographic salt value type (`Salt`)
+-   Encrypted-in-memory secret handling (`Secret`)
+-   Common cryptographic primitive abstraction (`ICryptoPrimitive`)