@digitaldefiance/ecies-lib 4.10.6 → 4.10.8

package/README.md

@@ -8,9 +8,9 @@ Production-ready, browser-compatible ECIES (Elliptic Curve Integrated Encryption
 
 Part of [Express Suite](https://github.com/Digital-Defiance/express-suite)
 
-**Current Version: v4.7.14**
+**Current Version: v4.10.7**
 
-This library implements a modern, enterprise-grade ECIES protocol (v4.0) featuring HKDF key derivation, AAD binding, and optimized multi-recipient encryption. It includes a pluggable ID provider system, memory-efficient streaming encryption, and comprehensive internationalization.
+This library implements a modern, enterprise-grade ECIES protocol (v4.0) featuring HKDF key derivation, AAD binding, and optimized multi-recipient encryption. It includes a pluggable ID provider system with PlatformID support, memory-efficient streaming encryption, comprehensive internationalization, and a complete cryptographic voting system with 15+ voting methods.
 
 ## Features
 
@@ -30,12 +30,24 @@ This library implements a modern, enterprise-grade ECIES protocol (v4.0) featuri
   - **Single**: Includes data length prefix.
   - **Multiple**: Efficient encryption for up to 65,535 recipients.
 
-### 🆔 Identity & Management
+### 🗳️ Cryptographic Voting System
+
+- **15+ Voting Methods**: Plurality, Approval, Weighted, Borda Count, Score, Ranked Choice (IRV), STAR, STV, Yes/No, Supermajority, and more
+- **Government-Grade Security**: Homomorphic encryption, verifiable receipts, immutable audit logs, public bulletin board
+- **Role Separation**: Poll aggregators cannot decrypt votes until closure (separate PollTallier)
+- **Multi-Round Support**: True IRV, STAR voting, STV with intermediate decryption
+- **Hierarchical Aggregation**: Precinct → County → State → National vote aggregation
+- **Event Logging**: Comprehensive audit trail with microsecond timestamps
+- **Browser Compatible**: Works in Node.js and modern browsers
+
+### 🆔 Enhanced Identity & Management
 
 - **Pluggable ID Providers**:
-  - **Flexible IDs**: Support for `ObjectId` (12 bytes), `GUID`/`UUID` (16 bytes), or custom formats (1-255 bytes).
-  - **Auto-Sync**: Configuration automatically adapts all cryptographic constants to the selected ID provider.
-  - **Member System**: User abstraction with cryptographic operations, fully integrated with the configured ID provider.
+  - **Flexible IDs**: Support for `ObjectId` (12 bytes), `GUID`/`UUID` (16 bytes), or custom formats (1-255 bytes)
+  - **PlatformID Type**: Generic type system supporting `Uint8Array | GuidV4 | ObjectId | string`
+  - **Auto-Sync**: Configuration automatically adapts all cryptographic constants to the selected ID provider
+  - **Member System**: User abstraction with cryptographic operations, fully integrated with the configured ID provider
+  - **Strong Typing**: New typed configuration system provides compile-time type safety for ID operations
 - **Key Management**:
   - **BIP39**: Mnemonic phrase generation (12-24 words).
   - **HD Wallets**: BIP32/BIP44 hierarchical deterministic derivation.
@@ -43,10 +55,11 @@ This library implements a modern, enterprise-grade ECIES protocol (v4.0) featuri
 
 ### 🚀 Advanced Capabilities
 
-- **Streaming Encryption**: Memory-efficient processing for large files (<10MB RAM usage for any file size).
-- **Internationalization (i18n)**: Automatic error translation in 8 languages (en-US, en-GB, fr, es, de, zh-CN, ja, uk).
-- **Runtime Configuration**: Injectable configuration profiles via `ConstantsRegistry` for dependency injection and testing.
-- **Cross-Platform**: Fully compatible with Node.js 18+ and modern browsers (Chrome, Edge, Firefox, Safari).
+- **Streaming Encryption**: Memory-efficient processing for large files (<10MB RAM usage for any file size)
+- **Internationalization (i18n)**: Automatic error translation in 8 languages (en-US, en-GB, fr, es, de, zh-CN, ja, uk)
+- **Runtime Configuration**: Injectable configuration profiles via `ConstantsRegistry` for dependency injection and testing
+- **Cross-Platform**: Fully compatible with Node.js 18+ and modern browsers (Chrome, Edge, Firefox, Safari)
+- **Voting System**: Complete cryptographic voting implementation with government-grade security requirements
 
 ## Installation
 
@@ -160,18 +173,25 @@ The library implements a robust ECIES variant designed for security and efficien
 
 ### ID Provider System
 
-The library is agnostic to the format of unique identifiers. The `IdProvider` system drives the entire configuration:
+The library is agnostic to the format of unique identifiers. The `IdProvider` system drives the entire configuration and now supports the `PlatformID` type for enhanced cross-platform compatibility:
 
 - **ObjectIdProvider** (Default): 12-byte MongoDB-style IDs.
 - **GuidV4Provider**: 16-byte raw GUIDs.
 - **UuidProvider**: 16-byte UUIDs (string representation handles dashes).
 - **CustomIdProvider**: Define your own size (1-255 bytes).
 
+The `PlatformID` type supports multiple ID formats:
+
+```typescript
+export type PlatformID = Uint8Array | GuidV4 | ObjectId | string;
+```
+
 When you configure an ID provider, the library automatically:
 
 - Updates `MEMBER_ID_LENGTH`.
 - Updates `ECIES.MULTIPLE.RECIPIENT_ID_SIZE`.
 - Validates that all internal constants are consistent.
+- Provides seamless integration with the voting system through generic type parameters.
 
 ## Quick Start
 
@@ -182,7 +202,8 @@ import {
   ECIESService, 
   getEciesI18nEngine, 
   createRuntimeConfiguration, 
-  ObjectIdProvider 
+  ObjectIdProvider,
+  getEnhancedIdProvider
 } from '@digitaldefiance/ecies-lib';
 
 // 1. Initialize i18n (required once)
@@ -208,9 +229,228 @@ const encrypted = await ecies.encryptSimpleOrSingle(false, publicKey, message);
 const decrypted = await ecies.decryptSimpleOrSingleWithHeader(false, privateKey, encrypted);
 
 console.log(new TextDecoder().decode(decrypted)); // "Hello, Secure World!"
+
+// 6. Strong Typing for ID Operations (NEW!)
+const idProvider = getEnhancedIdProvider<ObjectId>();
+const objectId = idProvider.generateTyped(); // Returns ObjectId - strongly typed!
+const serialized = idProvider.serializeTyped(objectId); // Accepts ObjectId directly
+const deserialized = idProvider.deserializeTyped(serialized); // Returns ObjectId
 ```
 
-### 2. Using Custom ID Providers (e.g., GUID)
+## Cryptographic Voting System
+
+The library includes a complete cryptographic voting system with government-grade security features, supporting 15+ voting methods from simple plurality to complex ranked choice voting.
+
+### Quick Start - Voting
+
+```typescript
+import { 
+  ECIESService, 
+  Member, 
+  MemberType, 
+  EmailString 
+} from '@digitaldefiance/ecies-lib';
+import { 
+  PollFactory, 
+  VoteEncoder, 
+  PollTallier, 
+  VotingMethod 
+} from '@digitaldefiance/ecies-lib/voting';
+
+// 1. Create authority with voting keys
+const ecies = new ECIESService();
+const { member: authority } = Member.newMember(
+  ecies,
+  MemberType.System,
+  'Election Authority',
+  new EmailString('authority@example.com')
+);
+await authority.deriveVotingKeys();
+
+// 2. Create poll
+const poll = PollFactory.createPlurality(
+  ['Alice', 'Bob', 'Charlie'],
+  authority
+);
+
+// 3. Create voter and cast vote
+const { member: voter } = Member.newMember(
+  ecies,
+  MemberType.User,
+  'Voter',
+  new EmailString('voter@example.com')
+);
+await voter.deriveVotingKeys();
+
+const encoder = new VoteEncoder(authority.votingPublicKey!);
+const vote = encoder.encodePlurality(0, 3); // Vote for Alice
+const receipt = poll.vote(voter, vote);
+
+// 4. Close and tally
+poll.close();
+const tallier = new PollTallier(
+  authority,
+  authority.votingPrivateKey!,
+  authority.votingPublicKey!
+);
+const results = tallier.tally(poll);
+
+console.log('Winner:', results.choices[results.winner!]);
+console.log('Tallies:', results.tallies);
+```
+
+### Supported Voting Methods
+
+The system supports 15+ voting methods classified by security level:
+
+#### ✅ Fully Secure (Single-round, Privacy-preserving)
+- **Plurality** - First-past-the-post (most common) ✅ **Fully Implemented**
+- **Approval** - Vote for multiple candidates ✅ **Fully Implemented**
+- **Weighted** - Stakeholder voting with configurable limits ✅ **Fully Implemented**
+- **Borda Count** - Ranked voting with point allocation ✅ **Fully Implemented**
+- **Score Voting** - Rate candidates 0-10 ✅ **Fully Implemented**
+- **Yes/No** - Referendums and ballot measures ✅ **Fully Implemented**
+- **Yes/No/Abstain** - With abstention option ✅ **Fully Implemented**
+- **Supermajority** - Requires 2/3 or 3/4 threshold ✅ **Fully Implemented**
+
+#### ⚠️ Multi-Round (Requires intermediate decryption)
+- **Ranked Choice (IRV)** - Instant runoff with elimination ✅ **Fully Implemented**
+- **Two-Round** - Top 2 runoff election ✅ **Fully Implemented**
+- **STAR** - Score Then Automatic Runoff ✅ **Fully Implemented**
+- **STV** - Single Transferable Vote (proportional representation) ✅ **Fully Implemented**
+
+#### ❌ Insecure (No privacy - for special cases only)
+- **Quadratic** - Quadratic voting (requires non-homomorphic operations) ✅ **Fully Implemented**
+- **Consensus** - Requires 95%+ agreement ✅ **Fully Implemented**
+- **Consent-Based** - Sociocracy-style (no strong objections) ✅ **Fully Implemented**
+
+### Voting System Architecture
+
+```
+┌─────────────────────────────────────────────────────────────┐
+│                    SECURE ARCHITECTURE                       │
+├─────────────────────────────────────────────────────────────┤
+│                                                              │
+│  Poll (Vote Aggregator)                                     │
+│  ├─ Paillier PUBLIC key only  ← encrypts & aggregates      │
+│  ├─ Authority's EC keys       ← signs receipts              │
+│  └─ Cannot decrypt votes                                    │
+│                                                              │
+│  PollTallier (Separate Entity)                              │
+│  ├─ Paillier PRIVATE key      ← decrypts ONLY after close  │
+│  └─ Computes results                                        │
+│                                                              │
+│  Voter (Member)                                             │
+│  ├─ EC keypair                ← verifies receipts           │
+│  └─ Voting public key         ← encrypts votes              │
+│                                                              │
+└─────────────────────────────────────────────────────────────┘
+```
+
+### Government Requirements
+
+The voting system meets government-grade requirements:
+
+- **✅ Immutable Audit Log** - Cryptographic hash chain for all operations
+- **✅ Public Bulletin Board** - Transparent, append-only vote publication with Merkle tree integrity
+- **✅ Event Logger** - Comprehensive event tracking with microsecond timestamps
+- **✅ Verifiable Receipts** - Cryptographically signed confirmations
+- **✅ Role Separation** - Poll aggregator cannot decrypt votes
+- **✅ Homomorphic Encryption** - Votes remain encrypted until tally
+
+### Example: Ranked Choice Voting
+
+```typescript
+import { PollFactory, VoteEncoder, PollTallier } from '@digitaldefiance/ecies-lib/voting';
+
+// Create ranked choice poll
+const poll = PollFactory.createRankedChoice(
+  ['Alice', 'Bob', 'Charlie', 'Diana'],
+  authority
+);
+
+const encoder = new VoteEncoder(authority.votingPublicKey!);
+
+// Voter ranks: Alice > Bob > Charlie (Diana not ranked)
+const vote = encoder.encodeRankedChoice([0, 1, 2], 4);
+const receipt = poll.vote(voter, vote);
+
+// Verify receipt
+const isValid = poll.verifyReceipt(voter, receipt);
+
+// Close and tally with IRV elimination
+poll.close();
+const results = tallier.tally(poll);
+
+console.log('Winner:', results.choices[results.winner!]);
+console.log('Elimination rounds:', results.rounds);
+```
+
+### Security Validation
+
+```typescript
+import { VotingSecurityValidator, SecurityLevel } from '@digitaldefiance/ecies-lib/voting';
+
+// Check security level
+const level = VotingSecurityValidator.getSecurityLevel(VotingMethod.Plurality);
+console.log(level); // SecurityLevel.FullyHomomorphic
+
+// Validate before use (throws if insecure)
+VotingSecurityValidator.validate(VotingMethod.Quadratic); // Throws error
+
+// Allow insecure methods explicitly
+VotingSecurityValidator.validate(VotingMethod.Quadratic, { allowInsecure: true });
+```
+
+### 2. Strong Typing for ID Providers (NEW!)
+
+The library now provides strongly-typed alternatives to the weak typing pattern `Constants.idProvider.generate()`:
+
+```typescript
+import { 
+  getRuntimeConfiguration,
+  getEnhancedIdProvider,
+  getTypedIdProvider,
+  createObjectIdConfiguration
+} from '@digitaldefiance/ecies-lib';
+import { ObjectId } from 'bson';
+
+// BEFORE: Weak typing (still works for compatibility)
+const Constants = getRuntimeConfiguration();
+const rawBytes = Constants.idProvider.generate(); // Returns Uint8Array, no strong typing
+const nativeId = Constants.idProvider.fromBytes(rawBytes); // Returns unknown, requires casting
+
+// AFTER: Strong typing - Option 1 (Enhanced Provider - Recommended)
+const enhancedProvider = getEnhancedIdProvider<ObjectId>();
+
+// Original methods still work exactly the same
+const rawBytes2 = enhancedProvider.generate(); // Uint8Array (same as before)
+const isValid = enhancedProvider.validate(rawBytes2); // boolean (same as before)
+
+// Plus new strongly-typed methods
+const objectId = enhancedProvider.generateTyped(); // ObjectId - strongly typed!
+const validTyped = enhancedProvider.validateTyped(objectId); // boolean, accepts ObjectId
+const serialized = enhancedProvider.serializeTyped(objectId); // string, accepts ObjectId
+const deserialized = enhancedProvider.deserializeTyped(serialized); // ObjectId
+
+// AFTER: Strong typing - Option 2 (Simple Typed Provider)
+const typedProvider = getTypedIdProvider<ObjectId>();
+const bytes = typedProvider.generate();
+const typedId = typedProvider.fromBytes(bytes); // Returns ObjectId, not unknown!
+
+// AFTER: Strong typing - Option 3 (Configuration Wrapper)
+const config = createObjectIdConfiguration();
+const configId = config.generateId(); // ObjectId directly!
+const configValid = config.validateId(configId); // boolean, accepts ObjectId
+```
+
+**Benefits:**
+- ✅ **Full IntelliSense** - Autocomplete for native ID methods (`objectId.toHexString()`)
+- ✅ **Compile-time checking** - Prevents type mismatches at build time
+- ✅ **Zero breaking changes** - All existing code continues to work
+- ✅ **Multiple migration paths** - Choose the approach that fits your use case
+
+### 3. Using Custom ID Providers (e.g., GUID)
 
 ```typescript
 import { 
@@ -229,7 +469,7 @@ const ecies = new ECIESService(config);
 const id = config.idProvider.generate(); // Returns 16-byte Uint8Array
 ```
 
-### 3. Streaming Encryption (Large Files)
+### 4. Streaming Encryption (Large Files)
 
 Encrypt gigabytes of data with minimal memory footprint (<10MB).
 
@@ -253,7 +493,7 @@ async function processFile(fileStream: ReadableStream, publicKey: Uint8Array) {
 }
 ```
 
-### 4. Member System
+### 5. Member System
 
 The `Member` class provides a high-level user abstraction that integrates keys, IDs, and encryption.
 
@@ -713,6 +953,19 @@ class MemberService {
 - **`EciesFileService`**: Helper for chunked file encryption.
 - **`PasswordLoginService`**: Secure authentication using PBKDF2 and encrypted key bundles.
 
+### Voting System Services
+
+- **`Poll`**: Core poll with vote aggregation and receipt generation
+- **`PollTallier`**: Decrypts and tallies votes (separate from Poll for security)
+- **`VoteEncoder`**: Encrypts votes using Paillier homomorphic encryption
+- **`PollFactory`**: Convenient poll creation with method-specific configurations
+- **`VotingSecurityValidator`**: Security level validation and enforcement
+- **`ImmutableAuditLog`**: Hash-chained audit trail for government compliance
+- **`PublicBulletinBoard`**: Append-only vote publication with Merkle tree integrity
+- **`PollEventLogger`**: Event tracking with microsecond timestamps
+- **Hierarchical Aggregators**: `PrecinctAggregator`, `CountyAggregator`, `StateAggregator`, `NationalAggregator`
+- **`BatchVoteProcessor`**: Batch processing and checkpoint management
+
 ### ID Providers
 
 - **`IIdProvider`**: Interface that all ID providers implement
@@ -737,6 +990,9 @@ class MemberService {
   - `id`: Unique identifier (format determined by ID provider)
   - `publicKey`: Member's public key
   - `privateKey`: Member's private key (optional, can be loaded/unloaded)
+  - `votingPublicKey`: Paillier public key for voting (optional)
+  - `votingPrivateKey`: Paillier private key for voting (optional)
+  - `deriveVotingKeys()`: Generate Paillier keypair for voting
   - `encryptData(data, recipientPublicKey?)`: Encrypt data
   - `decryptData(encryptedData)`: Decrypt data
   - `sign(data)`: Sign data with private key
@@ -746,6 +1002,25 @@ class MemberService {
   - `newMember(...)`: Static factory method
   - `fromMnemonic(...)`: Create from BIP39 mnemonic
 
+### Voting System Types & Enumerations
+
+- **`VotingMethod`**: Enum with 15+ voting methods (Plurality, Approval, Weighted, Borda, Score, RankedChoice, STAR, STV, etc.)
+- **`SecurityLevel`**: Enum classifying voting methods (FullyHomomorphic, MultiRound, Insecure)
+- **`EventType`**: Enum for event logging (PollCreated, VoteCast, PollClosed, etc.)
+- **`AuditEventType`**: Enum for audit events
+- **`JurisdictionalLevel`**: Enum for hierarchical aggregation (Precinct, County, State, National)
+
+### Voting System Interfaces
+
+- **`EncryptedVote<TID extends PlatformID>`**: Encrypted vote structure with generic ID support
+- **`PollResults<TID extends PlatformID>`**: Tally results with winner(s) and generic ID support
+- **`VoteReceipt`**: Cryptographic vote receipt with signature verification
+- **`PollConfiguration`**: Poll setup parameters
+- **`SupermajorityConfig`**: Threshold configuration for supermajority voting
+- **`AuditEntry`**: Immutable audit log entry
+- **`BulletinBoardEntry`**: Public bulletin board entry
+- **`EventLogEntry`**: Event log entry with timestamps
+
 ### Configuration & Registry
 
 - **`Constants`**: The default, immutable configuration object.
@@ -754,6 +1029,27 @@ class MemberService {
   - `get(key)`: Retrieve a configuration.
 - **`createRuntimeConfiguration(overrides)`**: Creates a validated configuration object with your overrides.
 
+### Strong Typing System (NEW!)
+
+- **`getEnhancedIdProvider<T>(key?)`**: Get a strongly-typed ID provider with enhanced convenience methods
+  - Drop-in replacement for `Constants.idProvider` with both original and typed methods
+  - `generateTyped()`: Generate ID with native type (e.g., `ObjectId`)
+  - `validateTyped(id)`: Validate ID with native type
+  - `serializeTyped(id)`: Serialize ID with native type
+  - `deserializeTyped(str)`: Deserialize to native type
+- **`getTypedIdProvider<T>(key?)`**: Get a simple strongly-typed ID provider
+  - Minimal API surface with type-safe conversions
+  - `fromBytes(bytes)`: Returns native type instead of `unknown`
+- **`createObjectIdConfiguration(overrides?)`**: Create ObjectId-typed configuration
+- **`createGuidV4Configuration(overrides?)`**: Create GuidV4-typed configuration
+- **`createUint8ArrayConfiguration(overrides?)`**: Create Uint8Array-typed configuration
+- **`createUuidConfiguration(overrides?)`**: Create UUID string-typed configuration
+- **`TypedConfiguration<T>`**: Configuration wrapper with strongly-typed ID operations
+  - `generateId()`: Generate ID with native type
+  - `validateId(id)`: Validate ID with native type
+  - `serializeId(id)`: Serialize ID with native type
+  - `deserializeId(str)`: Deserialize to native type
+
 ### Secure Primitives
 
 - **`SecureString` / `SecureBuffer`**:
@@ -962,6 +1258,188 @@ The library maintains **100% test coverage** with over 1,200 tests, including:
 
 ## ChangeLog
 
+### v4.10.7 - Strong Typing for ID Providers
+
+**Major Features:**
+- **Strong Typing System**: Added comprehensive strong typing solution for ID provider operations
+  - `getEnhancedIdProvider<T>()`: Drop-in replacement for `Constants.idProvider` with typed methods
+  - `getTypedIdProvider<T>()`: Simple typed provider for minimal API surface
+  - `createObjectIdConfiguration()`: ObjectId-typed configuration factory
+  - `TypedConfiguration<T>`: Configuration wrapper with strongly-typed ID operations
+- **Enhanced Developer Experience**: 
+  - Full IntelliSense support for native ID types (`ObjectId`, `GuidV4`, `string`, etc.)
+  - Compile-time type checking prevents runtime type errors
+  - Multiple migration paths to choose from based on use case
+- **Zero Breaking Changes**: All existing code continues to work unchanged
+  - Original `Constants.idProvider` pattern still supported
+  - Enhanced providers include all original methods plus typed alternatives
+  - Backward compatibility maintained for all existing APIs
+
+**New APIs:**
+- `getEnhancedIdProvider<T>(key?)`: Enhanced provider with typed convenience methods
+- `getTypedIdProvider<T>(key?)`: Simple typed provider
+- `createObjectIdConfiguration(overrides?)`: ObjectId-typed configuration
+- `createGuidV4Configuration(overrides?)`: GuidV4-typed configuration  
+- `createUint8ArrayConfiguration(overrides?)`: Uint8Array-typed configuration
+- `createUuidConfiguration(overrides?)`: UUID string-typed configuration
+- `TypedIdProviderWrapper<T>`: Enhanced wrapper with typed methods
+
+**Migration Examples:**
+```typescript
+// BEFORE: Weak typing
+const Constants = getRuntimeConfiguration();
+const id = Constants.idProvider.generate(); // Uint8Array, no strong typing
+
+// AFTER: Strong typing (multiple options)
+const enhancedProvider = getEnhancedIdProvider<ObjectId>();
+const objectId = enhancedProvider.generateTyped(); // ObjectId - strongly typed!
+
+const typedProvider = getTypedIdProvider<ObjectId>();
+const typedId = typedProvider.fromBytes(bytes); // ObjectId, not unknown!
+
+const config = createObjectIdConfiguration();
+const configId = config.generateId(); // ObjectId directly!
+```
+
+**Documentation:**
+- Added comprehensive migration guide (`src/migration-guide.md`)
+- Updated README with strong typing examples
+- Added usage examples and real-world migration patterns
+
+**Testing:**
+- 14 new tests covering all strong typing scenarios
+- Property-based tests for type safety validation
+- Migration pattern tests for backward compatibility
+
+### v4.10.6 - Voting System & PlatformID Integration
+
+**Major Features:**
+- **Complete Cryptographic Voting System**: Added comprehensive voting system with 15+ methods
+  - Fully secure methods: Plurality, Approval, Weighted, Borda, Score, Yes/No, Supermajority
+  - Multi-round methods: Ranked Choice (IRV), STAR, STV, Two-Round
+  - Government-grade security: Immutable audit logs, public bulletin board, event logging
+  - Role separation: Poll aggregators cannot decrypt votes until closure
+- **PlatformID Type System**: Enhanced ID provider system with generic type support
+  - `PlatformID = Uint8Array | GuidV4 | ObjectId | string`
+  - Generic interfaces: `EncryptedVote<TID extends PlatformID>`, `PollResults<TID extends PlatformID>`
+  - Seamless integration between voting system and ID providers
+- **Enhanced Member System**: Added voting key derivation and management
+  - `deriveVotingKeys()`: Generate Paillier keypairs for homomorphic encryption
+  - `votingPublicKey` and `votingPrivateKey` properties for voting operations
+  - Full integration with voting system interfaces
+
+**Voting System Components:**
+- `Poll`: Core vote aggregation with receipt generation
+- `PollTallier`: Secure vote decryption and tallying (separate entity)
+- `VoteEncoder`: Paillier homomorphic encryption for all voting methods
+- `PollFactory`: Convenient poll creation with method-specific configurations
+- `VotingSecurityValidator`: Security level validation and enforcement
+- `ImmutableAuditLog`: Cryptographic hash chain for audit compliance
+- `PublicBulletinBoard`: Transparent vote publication with Merkle tree integrity
+- `PollEventLogger`: Comprehensive event tracking with microsecond timestamps
+- Hierarchical aggregators: Precinct → County → State → National
+
+**Breaking Changes:**
+- Voting interfaces now use generic `PlatformID` types
+- Member interface extended with voting key properties
+- New voting system exports in main package
+
+**Compatibility:**
+- Fully backward compatible for existing ECIES operations
+- New voting system is opt-in and doesn't affect existing functionality
+- Cross-platform compatible with `@digitaldefiance/node-ecies-lib`
+
+### v4.10.5 - Voting System Enhancements
+
+**Improvements:**
+- Enhanced voting system test coverage
+- Updated showcase application with improved voting demos
+- Bug fixes and stability improvements
+
+### v4.10.0 - Complete Voting System Implementation
+
+**Major Features:**
+- **All 15 Voting Methods Fully Implemented**: Complete implementation of all voting methods with both encoding and showcase demos
+- **Interactive Showcase Application**: React-based demos for all voting methods
+  - Plurality, Approval, Weighted, Borda Count demos
+  - Score Voting, Yes/No, Yes/No/Abstain, Supermajority demos  
+  - Ranked Choice (IRV), Two-Round, STAR, STV demos
+  - Quadratic, Consensus, Consent-Based demos (marked as insecure)
+- **Enhanced Vote Encoding**: Generic `encode()` method supports all voting methods
+- **Comprehensive Testing**: Full test coverage for all voting methods and security levels
+
+### v4.9.1 - Voting System Refinements
+
+**Improvements:**
+- Enhanced voting system test suite
+- Improved showcase application stability
+- Bug fixes in voting method implementations
+
+### v4.9.0 - Voting System Core Implementation
+
+**Major Features:**
+- **Core Voting Infrastructure**: Implemented foundational voting system components
+- **Security Classifications**: Proper security level validation for all voting methods
+- **Homomorphic Encryption**: Paillier encryption for privacy-preserving vote aggregation
+- **Government Compliance**: Audit logging, bulletin board, and event tracking systems
+
+### v4.8.7 - Showcase Application Development
+
+**Improvements:**
+- Continued development of interactive voting demos
+- Enhanced user interface for voting demonstrations
+- Improved cryptographic visualization components
+
+### v4.8.6 - Voting System Testing & Refinements
+
+**Improvements:**
+- Enhanced test coverage for voting system components
+- Bug fixes in voting method implementations
+- Improved error handling and validation
+
+### v4.8.5 - Voting System Expansion
+
+**Features:**
+- Additional voting method implementations
+- Enhanced showcase application with more interactive demos
+- Improved voting system documentation
+
+### v4.8.3 - Voting System Development
+
+**Features:**
+- Continued voting system implementation
+- Enhanced cryptographic voting components
+- Improved test coverage
+
+### v4.8.2 - Voting System Foundation
+
+**Features:**
+- Initial voting system architecture
+- Core voting method implementations
+- Basic showcase application structure
+
+### v4.8.1 - Voting System Initialization
+
+**Features:**
+- Foundation for cryptographic voting system
+- Initial voting method definitions
+- Enhanced Member system for voting key management
+
+### v4.8.0 - Voting System Introduction
+
+**Major Features:**
+- **Initial Voting System**: Introduced cryptographic voting system architecture
+- **Voting Method Enumerations**: Defined all 15+ voting methods with security classifications
+- **Enhanced Member System**: Added voting key derivation capabilities
+- **Showcase Application**: Started development of interactive voting demos
+
+### v4.7.14 - Pre-Voting System Enhancements
+
+**Improvements:**
+- Enhanced core ECIES functionality
+- Improved ID provider system
+- Bug fixes and stability improvements
+
 ### v4.7.12
 
 **Bug Fix: idProvider Configuration Now Respected by Member.newMember()**
@@ -1367,7 +1845,18 @@ tests/
   ├── e2e/               # End-to-end encryption/decryption tests
   ├── property/          # Property-based tests for cryptographic properties
   ├── compatibility/     # Cross-platform compatibility tests
-  └── vectors/           # Test vectors for protocol validation
+  ├── vectors/           # Test vectors for protocol validation
+  └── voting/            # Voting system tests
+      ├── voting.spec.ts           # Core voting functionality (900+ tests)
+      ├── voting-stress.spec.ts    # Stress tests with large datasets
+      ├── poll-core.spec.ts        # Poll core functionality
+      ├── poll-audit.spec.ts       # Audit log integration
+      ├── factory.spec.ts          # Poll factory methods
+      ├── encoder.spec.ts          # Vote encoding for all methods
+      ├── security.spec.ts         # Security validation
+      ├── audit.spec.ts            # Immutable audit log
+      ├── bulletin-board.spec.ts   # Public bulletin board
+      └── event-logger.spec.ts     # Event logging system
 ```
 
 ### Running Tests
@@ -1382,6 +1871,11 @@ npm test -- --coverage
 # Run specific test suite
 npm test -- ecies-service.spec.ts
 
+# Run voting system tests
+npm test -- voting.spec.ts
+npm test -- voting-stress.spec.ts
+npm test -- poll-core.spec.ts
+
 # Run compatibility tests
 npm test -- cross-platform-compatibility.spec.ts
 
@@ -1459,6 +1953,68 @@ describe('Multi-Recipient Encryption', () => {
 });
 ```
 
+#### Testing Voting System
+
+```typescript
+import { ECIESService, Member, MemberType, EmailString } from '@digitaldefiance/ecies-lib';
+import { PollFactory, VoteEncoder, PollTallier, VotingMethod } from '@digitaldefiance/ecies-lib/voting';
+
+describe('Voting System', () => {
+  it('should conduct a complete ranked choice election', async () => {
+    const ecies = new ECIESService();
+    
+    // Create authority
+    const { member: authority } = Member.newMember(
+      ecies,
+      MemberType.System,
+      'Authority',
+      new EmailString('authority@example.com')
+    );
+    await authority.deriveVotingKeys();
+    
+    // Create poll
+    const poll = PollFactory.createRankedChoice(
+      ['Alice', 'Bob', 'Charlie'],
+      authority
+    );
+    
+    // Create voters and cast votes
+    const { member: voter1 } = Member.newMember(ecies, MemberType.User, 'Voter1', new EmailString('v1@example.com'));
+    await voter1.deriveVotingKeys();
+    
+    const encoder = new VoteEncoder(authority.votingPublicKey!);
+    const vote = encoder.encodeRankedChoice([0, 1, 2], 3); // Alice > Bob > Charlie
+    const receipt = poll.vote(voter1, vote);
+    
+    // Verify receipt
+    expect(poll.verifyReceipt(voter1, receipt)).toBe(true);
+    
+    // Close and tally
+    poll.close();
+    const tallier = new PollTallier(
+      authority,
+      authority.votingPrivateKey!,
+      authority.votingPublicKey!
+    );
+    const results = tallier.tally(poll);
+    
+    expect(results.winner).toBeDefined();
+    expect(results.choices[results.winner!]).toBe('Alice');
+  });
+  
+  it('should prevent double voting', async () => {
+    const poll = PollFactory.createPlurality(['A', 'B'], authority);
+    const encoder = new VoteEncoder(authority.votingPublicKey!);
+    
+    poll.vote(voter, encoder.encodePlurality(0, 2));
+    
+    expect(() => {
+      poll.vote(voter, encoder.encodePlurality(1, 2));
+    }).toThrow('Already voted');
+  });
+});
+```
+
 #### Testing ID Providers
 
 ```typescript
@@ -1520,6 +2076,10 @@ describe('Cryptographic Properties', () => {
 4. **Use property-based tests** for cryptographic invariants
 5. **Test error conditions** like invalid keys, corrupted data, and wrong recipients
 6. **Verify binary compatibility** with node-ecies-lib
+7. **Test all voting methods** across security levels (fully secure, multi-round, insecure)
+8. **Verify voting security** (double-vote prevention, receipt verification, role separation)
+9. **Test government requirements** (audit logs, bulletin board, event logging)
+10. **Stress test large elections** (1000+ voters, complex elimination rounds)
 
 ### Cross-Platform Testing
 
@@ -1555,5 +2115,5 @@ MIT © Digital Defiance
 
 - **Repository:** <https://github.com/Digital-Defiance/ecies-lib>
 - **npm:** <https://www.npmjs.com/package/@digitaldefiance/ecies-lib>
-- **Companion:** @digitaldefiance/node-ecies-lib (binary compatible)
+- **Companion:** @digitaldefiance/node-ecies-lib (binary compatible, extends this library with Buffer support and Node.js-specific features)
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@digitaldefiance/ecies-lib",
-  "version": "4.10.6",
+  "version": "4.10.8",
   "description": "Digital Defiance ECIES Library",
   "homepage": "https://github.com/Digital-Defiance/ecies-lib",
   "repository": {

package/src/examples/typed-configuration-usage.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Examples showing how to use the typed configuration system for strong ID provider typing.
+ * This demonstrates the solution to the original problem where Constants.idProvider.generate()
+ * had no strong typing.
+ */
+declare function beforeExample(): void;
+declare function afterExample(): void;
+declare function realWorldUsage(): void;
+declare function serviceIntegration(): void;
+declare function typeSafetyDemo(): void;
+export { beforeExample, afterExample, realWorldUsage, serviceIntegration, typeSafetyDemo, };
+//# sourceMappingURL=typed-configuration-usage.d.ts.map

package/src/examples/typed-configuration-usage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"typed-configuration-usage.d.ts","sourceRoot":"","sources":["../../../../../packages/digitaldefiance-ecies-lib/src/examples/typed-configuration-usage.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAiBH,iBAAS,aAAa,SAKrB;AAMD,iBAAS,YAAY,SAsBpB;AAMD,iBAAS,cAAc,SAsBtB;AAMD,iBAAS,kBAAkB,SAU1B;AAMD,iBAAS,cAAc,SAgBtB;AAED,OAAO,EACL,aAAa,EACb,YAAY,EACZ,cAAc,EACd,kBAAkB,EAClB,cAAc,GACf,CAAC"}

package/src/examples/typed-configuration-usage.js

@@ -0,0 +1,98 @@
+"use strict";
+/**
+ * Examples showing how to use the typed configuration system for strong ID provider typing.
+ * This demonstrates the solution to the original problem where Constants.idProvider.generate()
+ * had no strong typing.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.beforeExample = beforeExample;
+exports.afterExample = afterExample;
+exports.realWorldUsage = realWorldUsage;
+exports.serviceIntegration = serviceIntegration;
+exports.typeSafetyDemo = typeSafetyDemo;
+const constants_1 = require("../constants");
+const guidv4_provider_1 = require("../lib/id-providers/guidv4-provider");
+const typed_configuration_1 = require("../typed-configuration");
+// ============================================================================
+// BEFORE: Weak typing with getRuntimeConfiguration()
+// ============================================================================
+function beforeExample() {
+    // This was the original problem - no strong typing
+    const Constants = (0, constants_1.getRuntimeConfiguration)();
+    const id = Constants.idProvider.generate(); // Returns Uint8Array, loses type info
+    const _nativeId = Constants.idProvider.fromBytes(id); // Returns unknown, no type safety
+}
+// ============================================================================
+// AFTER: Strong typing solutions
+// ============================================================================
+function afterExample() {
+    // Solution 1: Direct replacement for Constants.idProvider
+    const enhancedProvider = (0, typed_configuration_1.getEnhancedIdProvider)();
+    // Original methods still work exactly the same
+    const rawBytes = enhancedProvider.generate(); // Uint8Array (same as before)
+    const _isValid = enhancedProvider.validate(rawBytes); // boolean (same as before)
+    // But now you also have strongly-typed methods
+    const objectId = enhancedProvider.generateTyped(); // ObjectId - strongly typed!
+    const _validTyped = enhancedProvider.validateTyped(objectId); // boolean, accepts ObjectId
+    const serialized = enhancedProvider.serializeTyped(objectId); // string, accepts ObjectId
+    const _deserialized = enhancedProvider.deserializeTyped(serialized); // ObjectId
+    // Solution 2: Simple typed provider
+    const typedProvider = (0, typed_configuration_1.getTypedIdProvider)();
+    const bytes = typedProvider.generate();
+    const _typedId = typedProvider.fromBytes(bytes); // Returns ObjectId, not unknown!
+    // Solution 3: Configuration approach (for more complex scenarios)
+    const config = (0, typed_configuration_1.createObjectIdConfiguration)();
+    const _configId = config.generateId(); // Returns ObjectId - strongly typed!
+}
+// ============================================================================
+// Real-world usage patterns
+// ============================================================================
+function realWorldUsage() {
+    // Pattern 1: Service initialization with strong typing
+    const config = (0, typed_configuration_1.createObjectIdConfiguration)();
+    // Now you can use config.idProvider with full type safety
+    const newId = config.generateId(); // ObjectId
+    const _isValid = config.validateId(newId); // boolean
+    const _idString = config.serializeId(newId); // string
+    // Pattern 2: Custom provider with type inference
+    const customProvider = new guidv4_provider_1.GuidV4Provider();
+    const typedConfig = (0, typed_configuration_1.createTypedConfiguration)({
+        idProvider: customProvider,
+        // Other overrides...
+        BcryptRounds: 12,
+    });
+    const _guidId = typedConfig.generateId(); // GuidV4 - automatically inferred!
+    // Pattern 3: Backward compatibility - access underlying constants
+    const _underlyingConstants = typedConfig.constants;
+    // This still works for existing code that expects IConstants
+}
+// ============================================================================
+// Integration with ECIESService
+// ============================================================================
+function serviceIntegration() {
+    // The ECIESService can now use TypedConfiguration for better typing
+    const config = (0, typed_configuration_1.createObjectIdConfiguration)();
+    // Pass the underlying constants to existing services
+    // const service = new ECIESService<ObjectId>(config.constants);
+    // Or use the typed config directly for ID operations
+    const memberId = config.generateId(); // ObjectId
+    const _memberIdString = config.serializeId(memberId); // string
+}
+// ============================================================================
+// Type safety demonstrations
+// ============================================================================
+function typeSafetyDemo() {
+    const objectIdConfig = (0, typed_configuration_1.createObjectIdConfiguration)();
+    const guidConfig = (0, typed_configuration_1.createGuidV4Configuration)({
+        idProvider: new guidv4_provider_1.GuidV4Provider(),
+    });
+    const objectId = objectIdConfig.generateId(); // ObjectId
+    const guid = guidConfig.generateId(); // GuidV4
+    // These operations are now type-safe:
+    objectIdConfig.serializeId(objectId); // ✅ Accepts ObjectId
+    guidConfig.serializeId(guid); // ✅ Accepts GuidV4
+    // These would be compile-time errors:
+    // objectIdConfig.serializeId(guid); // ❌ Type error: GuidV4 not assignable to ObjectId
+    // guidConfig.serializeId(objectId); // ❌ Type error: ObjectId not assignable to GuidV4
+}
+//# sourceMappingURL=typed-configuration-usage.js.map

package/src/examples/typed-configuration-usage.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"typed-configuration-usage.js","sourceRoot":"","sources":["../../../../../packages/digitaldefiance-ecies-lib/src/examples/typed-configuration-usage.ts"],"names":[],"mappings":"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"}

package/src/index.d.ts

@@ -15,6 +15,7 @@ export * from './lib/index';
 export { EciesComponentId, EciesI18nEngineKey, getEciesI18nEngine, getEciesTranslation, resetEciesI18nEngine, safeEciesTranslation, } from './i18n-setup';
 export { encryptionTypeEnumToType, encryptionTypeToString, ensureEciesEncryptionTypeEnum, validateEciesEncryptionTypeEnum, } from './utils/encryption-type-utils';
 export * from './constants';
+export * from './typed-configuration';
 export * from './email-string';
 export * from './enumerations';
 export * from './errors';

package/src/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../packages/digitaldefiance-ecies-lib/src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAIH,OAAO,uBAAuB,CAAC;AAG/B,cAAc,kBAAkB,CAAC;AACjC,cAAc,cAAc,CAAC;AAC7B,cAAc,aAAa,CAAC;AAG5B,OAAO,EACL,gBAAgB,EAChB,kBAAkB,EAClB,kBAAkB,EAClB,mBAAmB,EACnB,oBAAoB,EACpB,oBAAoB,GACrB,MAAM,cAAc,CAAC;AAItB,OAAO,EACL,wBAAwB,EACxB,sBAAsB,EACtB,6BAA6B,EAC7B,+BAA+B,GAChC,MAAM,+BAA+B,CAAC;AASvC,cAAc,aAAa,CAAC;AAC5B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,UAAU,CAAC;AACzB,cAAc,cAAc,CAAC;AAC7B,cAAc,8BAA8B,CAAC;AAC7C,OAAO,EAAE,wBAAwB,EAAE,MAAM,+BAA+B,CAAC;AACzE,YAAY,EAAE,gBAAgB,EAAE,MAAM,+BAA+B,CAAC;AACtE,cAAc,4BAA4B,CAAC;AAC3C,cAAc,4BAA4B,CAAC;AAC3C,cAAc,8BAA8B,CAAC;AAC7C,cAAc,oBAAoB,CAAC;AACnC,cAAc,mBAAmB,CAAC;AAClC,cAAc,UAAU,CAAC;AACzB,cAAc,mBAAmB,CAAC;AAClC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,iBAAiB,CAAC;AAChC,cAAc,iBAAiB,CAAC;AAChC,cAAc,YAAY,CAAC;AAC3B,cAAc,SAAS,CAAC;AACxB,cAAc,SAAS,CAAC;AAGxB,cAAc,cAAc,CAAC;AAG7B,YAAY,EACV,UAAU,EACV,SAAS,EACT,OAAO,IAAI,eAAe,GAC3B,MAAM,iBAAiB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../packages/digitaldefiance-ecies-lib/src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAIH,OAAO,uBAAuB,CAAC;AAG/B,cAAc,kBAAkB,CAAC;AACjC,cAAc,cAAc,CAAC;AAC7B,cAAc,aAAa,CAAC;AAG5B,OAAO,EACL,gBAAgB,EAChB,kBAAkB,EAClB,kBAAkB,EAClB,mBAAmB,EACnB,oBAAoB,EACpB,oBAAoB,GACrB,MAAM,cAAc,CAAC;AAItB,OAAO,EACL,wBAAwB,EACxB,sBAAsB,EACtB,6BAA6B,EAC7B,+BAA+B,GAChC,MAAM,+BAA+B,CAAC;AASvC,cAAc,aAAa,CAAC;AAC5B,cAAc,uBAAuB,CAAC;AACtC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,UAAU,CAAC;AACzB,cAAc,cAAc,CAAC;AAC7B,cAAc,8BAA8B,CAAC;AAC7C,OAAO,EAAE,wBAAwB,EAAE,MAAM,+BAA+B,CAAC;AACzE,YAAY,EAAE,gBAAgB,EAAE,MAAM,+BAA+B,CAAC;AACtE,cAAc,4BAA4B,CAAC;AAC3C,cAAc,4BAA4B,CAAC;AAC3C,cAAc,8BAA8B,CAAC;AAC7C,cAAc,oBAAoB,CAAC;AACnC,cAAc,mBAAmB,CAAC;AAClC,cAAc,UAAU,CAAC;AACzB,cAAc,mBAAmB,CAAC;AAClC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,iBAAiB,CAAC;AAChC,cAAc,iBAAiB,CAAC;AAChC,cAAc,YAAY,CAAC;AAC3B,cAAc,SAAS,CAAC;AACxB,cAAc,SAAS,CAAC;AAGxB,cAAc,cAAc,CAAC;AAG7B,YAAY,EACV,UAAU,EACV,SAAS,EACT,OAAO,IAAI,eAAe,GAC3B,MAAM,iBAAiB,CAAC"}

package/src/index.js

@@ -40,6 +40,7 @@ Object.defineProperty(exports, "validateEciesEncryptionTypeEnum", { enumerable:
 // Note: Existing services will be re-exported once migrated to v2
 // For now, import from main index.ts for backward compatibility
 tslib_1.__exportStar(require("./constants"), exports);
+tslib_1.__exportStar(require("./typed-configuration"), exports);
 tslib_1.__exportStar(require("./email-string"), exports);
 tslib_1.__exportStar(require("./enumerations"), exports);
 tslib_1.__exportStar(require("./errors"), exports);

package/src/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../packages/digitaldefiance-ecies-lib/src/index.ts"],"names":[],"mappings":";AAAA;;;;;;;;;GASG;;;;AAEH,mEAAmE;AACnE,wEAAwE;AACxE,iCAA+B;AAE/B,kBAAkB;AAClB,2DAAiC;AACjC,uDAA6B;AAC7B,sDAA4B;AAE5B,UAAU;AACV,2CAOsB;AANpB,8GAAA,gBAAgB,OAAA;AAChB,gHAAA,kBAAkB,OAAA;AAClB,gHAAA,kBAAkB,OAAA;AAClB,iHAAA,mBAAmB,OAAA;AACnB,kHAAA,oBAAoB,OAAA;AACpB,kHAAA,oBAAoB,OAAA;AAGtB,mFAAmF;AACnF,mEAAmE;AACnE,uEAKuC;AAJrC,iIAAA,wBAAwB,OAAA;AACxB,+HAAA,sBAAsB,OAAA;AACtB,sIAAA,6BAA6B,OAAA;AAC7B,wIAAA,+BAA+B,OAAA;AAGjC,2DAA2D;AAC3D,oEAAoE;AACpE,8DAA8D;AAE9D,kEAAkE;AAClE,gEAAgE;AAEhE,sDAA4B;AAC5B,yDAA+B;AAC/B,yDAA+B;AAC/B,mDAAyB;AACzB,uDAA6B;AAC7B,uEAA6C;AAC7C,kEAAyE;AAAhE,4HAAA,wBAAwB,OAAA;AAEjC,qEAA2C;AAC3C,qEAA2C;AAC3C,uEAA6C;AAC7C,6DAAmC;AACnC,4DAAkC;AAClC,mDAAyB;AACzB,4DAAkC;AAClC,yDAA+B;AAC/B,0DAAgC;AAChC,0DAAgC;AAChC,qDAA2B;AAC3B,kDAAwB;AACxB,kDAAwB;AAExB,qEAAqE;AACrE,uDAA6B"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../packages/digitaldefiance-ecies-lib/src/index.ts"],"names":[],"mappings":";AAAA;;;;;;;;;GASG;;;;AAEH,mEAAmE;AACnE,wEAAwE;AACxE,iCAA+B;AAE/B,kBAAkB;AAClB,2DAAiC;AACjC,uDAA6B;AAC7B,sDAA4B;AAE5B,UAAU;AACV,2CAOsB;AANpB,8GAAA,gBAAgB,OAAA;AAChB,gHAAA,kBAAkB,OAAA;AAClB,gHAAA,kBAAkB,OAAA;AAClB,iHAAA,mBAAmB,OAAA;AACnB,kHAAA,oBAAoB,OAAA;AACpB,kHAAA,oBAAoB,OAAA;AAGtB,mFAAmF;AACnF,mEAAmE;AACnE,uEAKuC;AAJrC,iIAAA,wBAAwB,OAAA;AACxB,+HAAA,sBAAsB,OAAA;AACtB,sIAAA,6BAA6B,OAAA;AAC7B,wIAAA,+BAA+B,OAAA;AAGjC,2DAA2D;AAC3D,oEAAoE;AACpE,8DAA8D;AAE9D,kEAAkE;AAClE,gEAAgE;AAEhE,sDAA4B;AAC5B,gEAAsC;AACtC,yDAA+B;AAC/B,yDAA+B;AAC/B,mDAAyB;AACzB,uDAA6B;AAC7B,uEAA6C;AAC7C,kEAAyE;AAAhE,4HAAA,wBAAwB,OAAA;AAEjC,qEAA2C;AAC3C,qEAA2C;AAC3C,uEAA6C;AAC7C,6DAAmC;AACnC,4DAAkC;AAClC,mDAAyB;AACzB,4DAAkC;AAClC,yDAA+B;AAC/B,0DAAgC;AAChC,0DAAgC;AAChC,qDAA2B;AAC3B,kDAAwB;AACxB,kDAAwB;AAExB,qEAAqE;AACrE,uDAA6B"}

package/src/typed-configuration.d.ts

@@ -0,0 +1,162 @@
+import type { ObjectId } from 'bson';
+import { type ConfigurationKey } from './constants';
+import type { IConstants } from './interfaces/constants';
+import type { IIdProvider } from './interfaces/id-provider';
+import type { GuidV4 } from './lib/guid';
+import type { DeepPartial } from './types/deep-partial';
+/**
+ * Typed configuration wrapper that preserves ID provider type information.
+ * This provides strong typing for idProvider operations without making the entire
+ * constants system generic.
+ */
+export declare class TypedConfiguration<TID> {
+    private readonly _constants;
+    private readonly _idProvider;
+    constructor(constants: IConstants);
+    /**
+     * Get the strongly-typed ID provider.
+     * This returns IIdProvider<TID> with full type safety.
+     */
+    get idProvider(): IIdProvider<TID>;
+    /**
+     * Get the underlying constants (for compatibility with existing code).
+     */
+    get constants(): IConstants;
+    /**
+     * Generate a new ID with strong typing.
+     */
+    generateId(): TID;
+    /**
+     * Validate an ID with strong typing.
+     */
+    validateId(id: TID): boolean;
+    /**
+     * Serialize an ID to string with strong typing.
+     */
+    serializeId(id: TID): string;
+    /**
+     * Deserialize a string to ID with strong typing.
+     */
+    deserializeId(str: string): TID;
+}
+/**
+ * Configuration factory functions that infer and preserve ID provider types.
+ */
+/**
+ * Create a typed configuration with ObjectId provider.
+ * This is the default configuration with strong ObjectId typing.
+ */
+export declare function createObjectIdConfiguration(overrides?: DeepPartial<IConstants>): TypedConfiguration<ObjectId>;
+/**
+ * Create a typed configuration with GuidV4 provider.
+ */
+export declare function createGuidV4Configuration(overrides?: DeepPartial<IConstants>): TypedConfiguration<GuidV4>;
+/**
+ * Create a typed configuration with Uint8Array provider (generic bytes).
+ */
+export declare function createUint8ArrayConfiguration(overrides?: DeepPartial<IConstants>): TypedConfiguration<Uint8Array>;
+/**
+ * Create a typed configuration with UUID string provider.
+ */
+export declare function createUuidConfiguration(overrides?: DeepPartial<IConstants>): TypedConfiguration<string>;
+/**
+ * Get a strongly-typed ID provider from the default configuration.
+ * This is the direct equivalent of `getRuntimeConfiguration().idProvider` with strong typing.
+ *
+ * @example
+ * ```typescript
+ * // BEFORE: Weak typing
+ * const Constants = getRuntimeConfiguration();
+ * const id = Constants.idProvider.generate(); // Returns Uint8Array, no strong typing
+ *
+ * // AFTER: Strong typing
+ * const idProvider = getTypedIdProvider<ObjectId>();
+ * const id = idProvider.generateTyped(); // Returns ObjectId - strongly typed!
+ * ```
+ */
+export declare function getTypedIdProvider<TID>(key?: ConfigurationKey): IIdProvider<TID>;
+/**
+ * Enhanced ID provider wrapper that adds strongly-typed convenience methods
+ * while preserving all original functionality.
+ */
+export declare class TypedIdProviderWrapper<TID> implements IIdProvider<TID> {
+    private readonly _provider;
+    constructor(provider: IIdProvider<TID>);
+    get byteLength(): number;
+    get name(): string;
+    generate(): Uint8Array;
+    validate(id: Uint8Array): boolean;
+    serialize(id: Uint8Array): string;
+    deserialize(str: string): Uint8Array;
+    toBytes(id: TID): Uint8Array;
+    fromBytes(bytes: Uint8Array): TID;
+    equals(a: TID, b: TID): boolean;
+    clone(id: TID): TID;
+    idToString(id: TID): string;
+    idFromString(str: string): TID;
+    /**
+     * Generate a new ID with strong typing.
+     * This is equivalent to generate() + fromBytes() but returns the native type directly.
+     */
+    generateTyped(): TID;
+    /**
+     * Validate an ID with strong typing.
+     * Accepts the native ID type and validates it.
+     */
+    validateTyped(id: TID): boolean;
+    /**
+     * Serialize an ID to string with strong typing.
+     * Accepts the native ID type directly.
+     */
+    serializeTyped(id: TID): string;
+    /**
+     * Deserialize a string to ID with strong typing.
+     * Returns the native ID type directly.
+     */
+    deserializeTyped(str: string): TID;
+}
+/**
+ * Get a strongly-typed ID provider with enhanced convenience methods.
+ * This provides the most ergonomic API for strongly-typed ID operations.
+ *
+ * @example
+ * ```typescript
+ * // Direct replacement for Constants.idProvider with strong typing
+ * const idProvider = getEnhancedIdProvider<ObjectId>();
+ *
+ * // All original methods work the same
+ * const bytes = idProvider.generate(); // Uint8Array
+ * const isValid = idProvider.validate(bytes); // boolean
+ *
+ * // Plus new strongly-typed methods
+ * const objectId = idProvider.generateTyped(); // ObjectId - strongly typed!
+ * const valid = idProvider.validateTyped(objectId); // boolean
+ * const serialized = idProvider.serializeTyped(objectId); // string
+ * const deserialized = idProvider.deserializeTyped(serialized); // ObjectId
+ * ```
+ */
+export declare function getEnhancedIdProvider<TID>(key?: ConfigurationKey): TypedIdProviderWrapper<TID>;
+/**
+ * Get a typed configuration from the registry.
+ * The type parameter must match the actual ID provider type.
+ *
+ * @example
+ * ```typescript
+ * // For ObjectId configurations
+ * const config = getTypedConfiguration<ObjectId>();
+ * const id = config.generateId(); // Returns ObjectId
+ *
+ * // For GUID configurations
+ * const guidConfig = getTypedConfiguration<GuidV4>('my-guid-config');
+ * const guid = guidConfig.generateId(); // Returns GuidV4
+ * ```
+ */
+export declare function getTypedConfiguration<TID>(key?: ConfigurationKey): TypedConfiguration<TID>;
+/**
+ * Type-safe configuration builder that infers the ID provider type.
+ * This provides the strongest typing by inferring TID from the idProvider.
+ */
+export declare function createTypedConfiguration<TProvider extends IIdProvider<unknown>>(config: DeepPartial<IConstants> & {
+    idProvider: TProvider;
+}): TypedConfiguration<TProvider extends IIdProvider<infer TID> ? TID : never>;
+//# sourceMappingURL=typed-configuration.d.ts.map

package/src/typed-configuration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"typed-configuration.d.ts","sourceRoot":"","sources":["../../../../packages/digitaldefiance-ecies-lib/src/typed-configuration.ts"],"names":[],"mappings":"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"}

package/src/typed-configuration.js

@@ -0,0 +1,247 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TypedIdProviderWrapper = exports.TypedConfiguration = void 0;
+exports.createObjectIdConfiguration = createObjectIdConfiguration;
+exports.createGuidV4Configuration = createGuidV4Configuration;
+exports.createUint8ArrayConfiguration = createUint8ArrayConfiguration;
+exports.createUuidConfiguration = createUuidConfiguration;
+exports.getTypedIdProvider = getTypedIdProvider;
+exports.getEnhancedIdProvider = getEnhancedIdProvider;
+exports.getTypedConfiguration = getTypedConfiguration;
+exports.createTypedConfiguration = createTypedConfiguration;
+const constants_1 = require("./constants");
+/**
+ * Typed configuration wrapper that preserves ID provider type information.
+ * This provides strong typing for idProvider operations without making the entire
+ * constants system generic.
+ */
+class TypedConfiguration {
+    _constants;
+    _idProvider;
+    constructor(constants) {
+        this._constants = constants;
+        this._idProvider = constants.idProvider;
+    }
+    /**
+     * Get the strongly-typed ID provider.
+     * This returns IIdProvider<TID> with full type safety.
+     */
+    get idProvider() {
+        return this._idProvider;
+    }
+    /**
+     * Get the underlying constants (for compatibility with existing code).
+     */
+    get constants() {
+        return this._constants;
+    }
+    /**
+     * Generate a new ID with strong typing.
+     */
+    generateId() {
+        const bytes = this._idProvider.generate();
+        return this._idProvider.fromBytes(bytes);
+    }
+    /**
+     * Validate an ID with strong typing.
+     */
+    validateId(id) {
+        const bytes = this._idProvider.toBytes(id);
+        return this._idProvider.validate(bytes);
+    }
+    /**
+     * Serialize an ID to string with strong typing.
+     */
+    serializeId(id) {
+        return this._idProvider.idToString(id);
+    }
+    /**
+     * Deserialize a string to ID with strong typing.
+     */
+    deserializeId(str) {
+        return this._idProvider.idFromString(str);
+    }
+}
+exports.TypedConfiguration = TypedConfiguration;
+/**
+ * Configuration factory functions that infer and preserve ID provider types.
+ */
+/**
+ * Create a typed configuration with ObjectId provider.
+ * This is the default configuration with strong ObjectId typing.
+ */
+function createObjectIdConfiguration(overrides) {
+    const constants = (0, constants_1.createRuntimeConfiguration)(overrides);
+    return new TypedConfiguration(constants);
+}
+/**
+ * Create a typed configuration with GuidV4 provider.
+ */
+function createGuidV4Configuration(overrides) {
+    const constants = (0, constants_1.createRuntimeConfiguration)(overrides);
+    return new TypedConfiguration(constants);
+}
+/**
+ * Create a typed configuration with Uint8Array provider (generic bytes).
+ */
+function createUint8ArrayConfiguration(overrides) {
+    const constants = (0, constants_1.createRuntimeConfiguration)(overrides);
+    return new TypedConfiguration(constants);
+}
+/**
+ * Create a typed configuration with UUID string provider.
+ */
+function createUuidConfiguration(overrides) {
+    const constants = (0, constants_1.createRuntimeConfiguration)(overrides);
+    return new TypedConfiguration(constants);
+}
+/**
+ * Get a strongly-typed ID provider from the default configuration.
+ * This is the direct equivalent of `getRuntimeConfiguration().idProvider` with strong typing.
+ *
+ * @example
+ * ```typescript
+ * // BEFORE: Weak typing
+ * const Constants = getRuntimeConfiguration();
+ * const id = Constants.idProvider.generate(); // Returns Uint8Array, no strong typing
+ *
+ * // AFTER: Strong typing
+ * const idProvider = getTypedIdProvider<ObjectId>();
+ * const id = idProvider.generateTyped(); // Returns ObjectId - strongly typed!
+ * ```
+ */
+function getTypedIdProvider(key) {
+    const constants = (0, constants_1.getRuntimeConfiguration)(key);
+    return constants.idProvider;
+}
+/**
+ * Enhanced ID provider wrapper that adds strongly-typed convenience methods
+ * while preserving all original functionality.
+ */
+class TypedIdProviderWrapper {
+    _provider;
+    constructor(provider) {
+        this._provider = provider;
+    }
+    // Delegate all original methods
+    get byteLength() {
+        return this._provider.byteLength;
+    }
+    get name() {
+        return this._provider.name;
+    }
+    generate() {
+        return this._provider.generate();
+    }
+    validate(id) {
+        return this._provider.validate(id);
+    }
+    serialize(id) {
+        return this._provider.serialize(id);
+    }
+    deserialize(str) {
+        return this._provider.deserialize(str);
+    }
+    toBytes(id) {
+        return this._provider.toBytes(id);
+    }
+    fromBytes(bytes) {
+        return this._provider.fromBytes(bytes);
+    }
+    equals(a, b) {
+        return this._provider.equals(a, b);
+    }
+    clone(id) {
+        return this._provider.clone(id);
+    }
+    idToString(id) {
+        return this._provider.idToString(id);
+    }
+    idFromString(str) {
+        return this._provider.idFromString(str);
+    }
+    // Add strongly-typed convenience methods
+    /**
+     * Generate a new ID with strong typing.
+     * This is equivalent to generate() + fromBytes() but returns the native type directly.
+     */
+    generateTyped() {
+        const bytes = this.generate();
+        return this.fromBytes(bytes);
+    }
+    /**
+     * Validate an ID with strong typing.
+     * Accepts the native ID type and validates it.
+     */
+    validateTyped(id) {
+        const bytes = this.toBytes(id);
+        return this.validate(bytes);
+    }
+    /**
+     * Serialize an ID to string with strong typing.
+     * Accepts the native ID type directly.
+     */
+    serializeTyped(id) {
+        return this.idToString(id);
+    }
+    /**
+     * Deserialize a string to ID with strong typing.
+     * Returns the native ID type directly.
+     */
+    deserializeTyped(str) {
+        return this.idFromString(str);
+    }
+}
+exports.TypedIdProviderWrapper = TypedIdProviderWrapper;
+/**
+ * Get a strongly-typed ID provider with enhanced convenience methods.
+ * This provides the most ergonomic API for strongly-typed ID operations.
+ *
+ * @example
+ * ```typescript
+ * // Direct replacement for Constants.idProvider with strong typing
+ * const idProvider = getEnhancedIdProvider<ObjectId>();
+ *
+ * // All original methods work the same
+ * const bytes = idProvider.generate(); // Uint8Array
+ * const isValid = idProvider.validate(bytes); // boolean
+ *
+ * // Plus new strongly-typed methods
+ * const objectId = idProvider.generateTyped(); // ObjectId - strongly typed!
+ * const valid = idProvider.validateTyped(objectId); // boolean
+ * const serialized = idProvider.serializeTyped(objectId); // string
+ * const deserialized = idProvider.deserializeTyped(serialized); // ObjectId
+ * ```
+ */
+function getEnhancedIdProvider(key) {
+    const provider = getTypedIdProvider(key);
+    return new TypedIdProviderWrapper(provider);
+}
+/**
+ * Get a typed configuration from the registry.
+ * The type parameter must match the actual ID provider type.
+ *
+ * @example
+ * ```typescript
+ * // For ObjectId configurations
+ * const config = getTypedConfiguration<ObjectId>();
+ * const id = config.generateId(); // Returns ObjectId
+ *
+ * // For GUID configurations
+ * const guidConfig = getTypedConfiguration<GuidV4>('my-guid-config');
+ * const guid = guidConfig.generateId(); // Returns GuidV4
+ * ```
+ */
+function getTypedConfiguration(key) {
+    const constants = (0, constants_1.getRuntimeConfiguration)(key);
+    return new TypedConfiguration(constants);
+}
+/**
+ * Type-safe configuration builder that infers the ID provider type.
+ * This provides the strongest typing by inferring TID from the idProvider.
+ */
+function createTypedConfiguration(config) {
+    const constants = (0, constants_1.createRuntimeConfiguration)(config);
+    return new TypedConfiguration(constants);
+}
+//# sourceMappingURL=typed-configuration.js.map

package/src/typed-configuration.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"typed-configuration.js","sourceRoot":"","sources":["../../../../packages/digitaldefiance-ecies-lib/src/typed-configuration.ts"],"names":[],"mappings":"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"}