reliant-type 1.0.0 → 2.1.4

package/README.md

@@ -1,17 +1,17 @@
 # ReliantType
 
 [![npm version](https://badge.fury.io/js/reliant-type.svg)](https://badge.fury.io/js/reliant-type)
-[![TypeScript](https://img.shields.io/badge/%3C%2F%3E-TypeScript-%230074c1.svg)](http://www.typescriptlang.org/)
+[![TypeScript](https://img.shields.io/badge/-TypeScript-%230074c1.svg)](http://www.typescriptlang.org/)
 [![Build Status](https://github.com/nehonisteam/ReliantType/workflows/CI/badge.svg)](https://github.com/nehonisteam/ReliantType/actions)
 [![Bundle Size](https://img.shields.io/bundlephobia/minzip/reliant-type)](https://bundlephobia.com/package/reliant-type)
-[![VS Code Extension](https://img.shields.io/badge/VS%20Code-Extension%20Available-blue)](https://sdk.nehonix.space/pkgs/mods/vscode/latest/reliant-type.vsix)
+[![VS Code Extension](https://img.shields.io/badge/VS%20Code-Extension%20Available-blue)](https://sdk.nehonix.com/pkgs/mods/vscode/latest/reliant-type.vsix)
 
 <div align="center">
-  <img src="https://sdk.nehonix.space/sdks/assets/reliant-type.jpg" alt="ReliantType Logo" width="250" />
+  <img src="https://sdk.nehonix.com/sdks/assets/reliant-type.jpg" alt="ReliantType Logo" width="250" />
 </div>
 
 <div align="center">
-  <img src="https://sdk.nehonix.space/sdks/assets/vscode-extension-preview.gif" alt="VSCode extension preview" width="500" />
+  <img src="https://sdk.nehonix.com/sdks/assets/vscode-extension-preview.gif" alt="VSCode extension preview" width="500" />
 </div>
 
 **TypeScript Schema Validation with Interface-Like Syntax**
@@ -20,15 +20,16 @@ A modern TypeScript validation library designed around familiar interface syntax
 
 > **Formerly Fortify Schema** - Originally developed at [github.com/Nehonix-Team/fortify-schema](https://github.com/Nehonix-Team/fortify-schema)
 
-⚠️ **Migration Notice**: The `fortify-schema` package will be deprecated in favor of `reliant-type`. While `fortify-schema` will continue to receive critical security updates, new features and improvements will only be available in `reliant-type`. We recommend migrating to `reliant-type` for the best experience and ongoing support.
+**Migration Notice**: The `fortify-schema` package will be deprecated in favor of `reliant-type`. While `fortify-schema` will continue to receive critical security updates, new features and improvements will only be available in `reliant-type`. We recommend migrating to `reliant-type` for the best experience and ongoing support.
 
-## 🆕 What's New
+## New Features
 
-- **Required Fields (`!`)**: Enforce non-empty strings and non-zero numbers with `"string!"` and `"number!"`
-- **Object Types**: Validate generic object structures with `"object"` and `"object?"`
-- **Enhanced Security**: All string operations now use secure regex patterns instead of potentially vulnerable methods
-- **Improved Performance**: Optimized validation paths with better caching and precompilation
-- **Better Error Messages**: More descriptive validation errors with clear property paths
+- **Function Types**: Define strict contracts for functions with `fn(...)` syntax, enforcing argument types and return values at runtime.
+- **Required Fields**: Enforce non-empty strings and non-zero numbers with `"string!"` and `"number!"`.
+- **Object Types**: Validate generic object structures with `"object"` and `"object?"`.
+- **Enhanced Security**: All string operations now use secure regex patterns.
+- **Improved Performance**: Optimized validation paths with better caching and precompilation.
+- **Better Error Messages**: More descriptive validation errors with clear property paths.
 
 ## Quick Start
 
@@ -42,12 +43,15 @@ import { Interface } from "reliant-type";
 // Define schemas with familiar TypeScript-like syntax
 const UserSchema = Interface({
   id: "uuid",
-  email: "email!", // 🆕 Required (non-empty) email
-  name: "string(2,50)!", // 🆕 Required string with length constraints
+  email: "email!", // Required (non-empty) email
+  name: "string(2,50)!", // Required string with length constraints
   age: "number(18,120)?",
   role: "admin|user|guest",
 
-  // 🆕 Object and array types
+  // Function validation
+  onUpdate: "fn((status: string) => boolean)",
+
+  // Object and array types
   profile: "object", // Any object structure
   tags: "string[]", // Array of strings
   metadata: "record<string, any>", // Dynamic key-value pairs
@@ -70,16 +74,14 @@ _Note: For nested objects, we recommend limiting depth to 50-100 or no more than
 
 Test by running:
 
-- bun src\_\_tests\_\_\test_nested_obj.ts note: you may have bun installed if using this command. "npm i -g bun" (recommanded because it's faster than node)
-
-- npm run benchmark:nestedObject
-
-_Note: you may have tsx installed if using this command. "npm i -g tsx"._
+- `bun src/__tests__/test_nested_obj.ts` (requires bun: `npm i -g bun`)
+- `npm run benchmark:nestedObject` (requires tsx: `npm i -g tsx`)
 
 ## Table of Contents
 
 - [Installation & Setup](#installation--setup)
 - [Core Features](#core-features)
+- [Function Types](#function-types)
 - [Utility Functions](#utility-functions)
 - [Conditional Validation](#conditional-validation)
 - [Live Utility - Real-time Validation](#live-utility---real-time-validation)
@@ -117,29 +119,29 @@ bun add reliant-type
 
 Enhance your development workflow with our dedicated VS Code extension featuring comprehensive developer tools:
 
-#### **🎨 Enhanced Features**
+#### Enhanced Features
 
-- **Syntax Highlighting**: Full syntax highlighting for all Reliant Type types and utilities
-- **Hover Documentation**: Detailed type information, examples, and use cases on hover
-- **Go-to-Definition**: Ctrl+Click on types to open comprehensive documentation
-- **IntelliSense Support**: Smart autocomplete for schema definitions
-- **Error Detection**: Real-time validation of schema syntax
-- **Code Snippets**: Pre-built templates for common schema patterns
+- **Syntax Highlighting**: Full syntax highlighting for all Reliant Type types and utilities.
+- **Hover Documentation**: Detailed type information, examples, and use cases on hover.
+- **Go-to-Definition**: Ctrl+Click on types to open comprehensive documentation.
+- **IntelliSense Support**: Smart autocomplete for schema definitions.
+- **Error Detection**: Real-time validation of schema syntax.
+- **Code Snippets**: Pre-built templates for common schema patterns.
 
-#### **📖 Interactive Documentation**
+#### Interactive Documentation
 
 When you hover over any type in `Interface({...})` blocks, you'll see:
 
-- **Type Description**: What the type validates
-- **Usage Examples**: `"string"`, `"string?"`, `"string[]"`
-- **Use Cases**: When and where to use each type
-- **Code Examples**: Complete working examples
+- **Type Description**: What the type validates.
+- **Usage Examples**: `"string"`, `"string?"`, `"string[]"`.
+- **Use Cases**: When and where to use each type.
+- **Code Examples**: Complete working examples.
 
-#### **🔧 Installation**
+#### Installation
 
 ```bash
 # Download and install
-curl https://sdk.nehonix.space/pkgs/mods/vscode/latest/reliant-type.vsix -o reliant-type.vsix
+curl https://sdk.nehonix.com/pkgs/mods/vscode/latest/reliant-type.vsix -o reliant-type.vsix
 code --install-extension reliant-type.vsix
 
 # Or just search for "reliant-type" in the vscode marketplace
@@ -193,7 +195,7 @@ const ComprehensiveSchema = Interface({
   nickname: "string?",
   bio: "string?",
 
-  // 🆕 Required fields (cannot be empty/zero)
+  // Required fields (cannot be empty/zero)
   requiredName: "string!", // Non-empty string required
   requiredCount: "number!", // Non-zero number required
 
@@ -219,7 +221,7 @@ const ComprehensiveSchema = Interface({
   status: "active|inactive|pending",
   role: "user|admin|moderator",
 
-  // 🆕 Object types
+  // Object types
   profile: "object", // Any object
   config: "object?", // Optional object
 
@@ -234,37 +236,52 @@ const ComprehensiveSchema = Interface({
 });
 ```
 
-### Deep Object Validation
+## Function Types
+
+ReliantType introduces powerful runtime and compile-time validation for function signatures using the `fn` type. This feature allows you to define strict contracts for functions within your schema.
+
+### Syntax
 
 ```typescript
-const UserProfileSchema = Interface({
-  user: {
-    id: "uuid",
-    email: "email",
-    profile: {
-      firstName: "string(1,50)",
-      lastName: "string(1,50)",
-      avatar: "url?",
-      preferences: {
-        theme: "light|dark|auto",
-        language: "string(/^[a-z]{2}$/)",
-        notifications: "boolean",
-      },
-    },
-  },
-  metadata: {
-    createdAt: "date",
-    lastLogin: "date?",
-    loginCount: "number(0,)",
-  },
+"fn((argument_list) => return_type)";
+```
+
+### Examples
+
+```typescript
+const ServiceSchema = Interface({
+  // Basic function: takes string, returns boolean
+  isValid: "fn((input: string) => boolean)",
+
+  // Multiple arguments
+  add: "fn((a: number, b: number) => number)",
+
+  // Optional arguments
+  log: "fn((message: string, context?: object) => void)",
+
+  // Rest parameters (Spread operator)
+  sum: "fn((...numbers: number[]) => number)",
+
+  // Generic placeholder (TYPE = any)
+  transform: "fn((input: TYPE) => TYPE)",
 });
 ```
 
-### Utility Functions
+### Runtime Behavior
+
+When a function defined in a schema is accessed, it is wrapped in a validation proxy that enforces:
+
+1.  **Argument Count**: Throws an error if required arguments are missing.
+2.  **Argument Types**: Throws an error if arguments do not match defined types.
+3.  **Return Type**: Throws an error if the return value does not match the defined type.
+
+This ensures strict contract adherence during execution.
+
+## Utility Functions
 
 Reliant Type provides powerful utility functions for advanced schema definition:
 
-#### **Make.const() - Constant Values**
+### Make.const() - Constant Values
 
 Create schemas that validate against exact constant values:
 
@@ -292,17 +309,9 @@ const ConfigSchema = Interface({
   // Array constants
   supportedFormats: Make.const(["json", "xml", "csv"]),
 });
-
-// Usage
-const config = {
-  apiVersion: "v2.1", // ✅ Valid
-  environment: "staging", // ❌ Invalid - must be exactly "production"
-  maxRetries: 3, // ✅ Valid
-  timeout: 3000, // ❌ Invalid - must be exactly 5000
-};
 ```
 
-#### **Record Types - Dynamic Objects**
+### Record Types - Dynamic Objects
 
 Validate objects with dynamic keys but consistent value types:
 
@@ -320,25 +329,6 @@ const DynamicSchema = Interface({
   // Optional record types
   optionalSettings: "record<string, boolean>?",
 });
-
-// Usage
-const data = {
-  metadata: {
-    userId: "123",
-    timestamp: new Date(),
-    flags: ["active", "verified"],
-  },
-  scores: {
-    math: 95,
-    science: 87,
-    english: 92,
-  },
-  translations: {
-    hello: "Hola",
-    goodbye: "Adiós",
-    welcome: "Bienvenido",
-  },
-};
 ```
 
 ## Conditional Validation
@@ -358,7 +348,7 @@ const SmartUserSchema = Interface({
   role: "admin|user|guest",
 
   // Dynamic validation based on runtime state
-  hasPermissions: "when config.permissions.$exists() *? boolean : =false",
+  hasPermissions: "when config.permissions.$exists() *? string[] : =[]",
   hasProfile: "when user.profile.$exists() *? boolean : =false",
   isListEmpty: "when config.items.$empty() *? boolean : =true",
   hasAdminRole: "when user.roles.$contains(admin) *? boolean : =false",
@@ -408,19 +398,19 @@ const RuntimeMethodsSchema = Interface({
 });
 ```
 
-## Live Utility - Real-time Validation (still in progress so not recommended for production use yet)
+## Live Utility - Real-time Validation
 
 The Live utility transforms Reliant Type into a powerful real-time validation system with EventEmitter-like interface, data transformation pipelines, and stream control methods. Perfect for modern applications requiring reactive validation.
 
 ### Key Features
 
-- **Real-time Field Validation** - Validate form fields as users type
-- **EventEmitter Interface** - Full `.on()`, `.emit()`, `.off()`, `.once()` support
-- **Data Transformation Pipeline** - Chain `.transform()`, `.filter()`, `.map()` operations
-- **Stream Control** - `.pause()`, `.resume()`, `.destroy()` for flow control
-- **Stream Piping** - Connect validators with `.pipe()` for complex workflows
-- **Performance Monitoring** - Built-in statistics and performance tracking
-- **InterfaceSchema Sync** - Perfect synchronization with Interface validation
+- **Real-time Field Validation**: Validate form fields as users type.
+- **EventEmitter Interface**: Full `.on()`, `.emit()`, `.off()`, `.once()` support.
+- **Data Transformation Pipeline**: Chain `.transform()`, `.filter()`, `.map()` operations.
+- **Stream Control**: `.pause()`, `.resume()`, `.destroy()` for flow control.
+- **Stream Piping**: Connect validators with `.pipe()` for complex workflows.
+- **Performance Monitoring**: Built-in statistics and performance tracking.
+- **InterfaceSchema Sync**: Perfect synchronization with Interface validation.
 
 ### Quick Example
 
@@ -440,62 +430,14 @@ const validator = Live.stream(UserSchema)
   .map((data) => ({ ...data, name: data.name.toUpperCase() }));
 
 // Listen for results
-validator.on("valid", (data) => console.log("✅ Valid:", data));
-validator.on("invalid", (data, errors) => console.log("❌ Invalid:", errors));
-validator.on("filtered", (data) => console.log("🚫 Filtered:", data));
+validator.on("valid", (data) => console.log("Valid:", data));
+validator.on("invalid", (data, errors) => console.log("Invalid:", errors));
+validator.on("filtered", (data) => console.log("Filtered:", data));
 
 // Process data
 validator.validate({ name: "john", email: "john@example.com", age: 25 });
-// Output: ✅ Valid: { name: "JOHN", email: "john@example.com", age: 25, timestamp: 1703123456789 }
-```
-
-### Stream Control Example
-
-```typescript
-const streamValidator = Live.stream(UserSchema);
-
-// Pause stream (queues data)
-streamValidator.pause();
-streamValidator.validate(userData1); // Queued
-streamValidator.validate(userData2); // Queued
-
-console.log("Queue length:", streamValidator.queueLength); // 2
-
-// Resume and process queue
-streamValidator.resume(); // Processes both queued items
-
-// Stream piping
-const sourceValidator = Live.stream(InputSchema);
-const destinationValidator = Live.stream(OutputSchema);
-
-sourceValidator.pipe(destinationValidator);
-// Valid data flows: source → destination
 ```
 
-### Form Integration Example
-
-```typescript
-const formValidator = Live.form(UserSchema);
-
-// Bind form fields
-formValidator.bindField("email", emailInput);
-formValidator.bindField("name", nameInput);
-
-// Enable real-time validation
-formValidator.enableAutoValidation();
-
-// Handle form submission
-formValidator.onSubmit((isValid, data, errors) => {
-  if (isValid) {
-    submitToAPI(data);
-  } else {
-    displayErrors(errors);
-  }
-});
-```
-
-The Live utility provides **100% coverage** of standard stream methods while maintaining **perfect synchronization** with InterfaceSchema validation logic.
-
 ## Real-World Applications
 
 ### E-Commerce Product Management
@@ -584,22 +526,10 @@ const performanceFeatures = {
 
 Our continuous performance monitoring shows excellent results across all validation scenarios:
 
-- **High Throughput**: Millions of operations per second for common validation patterns
-- **Consistent Performance**: Low variation in execution times
-- **Memory Efficient**: Minimal memory overhead per schema instance
-- **Scalable**: Performance scales predictably with data complexity
-
-### Performance Testing
-
-Validate performance on your specific use cases:
-
-```bash
-# Run comprehensive benchmarks
-bun run scripts/benchmark.js
-
-```
-
-View detailed [benchmark results](./src/bench/BENCHMARK-RESULTS.md) for comprehensive performance analysis.
+- **High Throughput**: Millions of operations per second for common validation patterns.
+- **Consistent Performance**: Low variation in execution times.
+- **Memory Efficient**: Minimal memory overhead per schema instance.
+- **Scalable**: Performance scales predictably with data complexity.
 
 ## Advanced Capabilities
 
@@ -663,11 +593,11 @@ try {
 
 Our dedicated VS Code extension transforms your development experience:
 
-- **Intelligent Syntax Highlighting** for schema definitions
-- **Advanced IntelliSense** with type and method completion
-- **Real-time Validation** with inline error detection
-- **Rich Hover Documentation** for all types and methods
-- **Multiple Theme Support** for different coding preferences
+- **Intelligent Syntax Highlighting** for schema definitions.
+- **Advanced IntelliSense** with type and method completion.
+- **Real-time Validation** with inline error detection.
+- **Rich Hover Documentation** for all types and methods.
+- **Multiple Theme Support** for different coding preferences.
 
 ```typescript
 const UserSchema = Interface({
@@ -687,30 +617,30 @@ const UserSchema = Interface({
 
 ### Design Philosophy
 
-- **Developer-Centric**: Built around familiar TypeScript patterns and conventions
-- **Interface Syntax**: Schema definitions that feel like native TypeScript interfaces
-- **Conditional Intelligence**: Advanced runtime validation based on dynamic properties
-- **Performance Focused**: Optimized for high-throughput production applications
-- **Tooling Excellence**: Professional-grade development tools and IDE integration
-- **Type Safety**: Complete TypeScript inference and compile-time validation
+- **Developer-Centric**: Built around familiar TypeScript patterns and conventions.
+- **Interface Syntax**: Schema definitions that feel like native TypeScript interfaces.
+- **Conditional Intelligence**: Advanced runtime validation based on dynamic properties.
+- **Performance Focused**: Optimized for high-throughput production applications.
+- **Tooling Excellence**: Professional-grade development tools and IDE integration.
+- **Type Safety**: Complete TypeScript inference and compile-time validation.
 
 ### Key Strengths
 
-- **Familiar Syntax**: Write schemas using TypeScript-like interface definitions
-- **Advanced Conditionals**: Unique runtime property validation and business logic
-- **Rich Tooling**: Dedicated VS Code extension with comprehensive development support
-- **Type Integration**: Seamless TypeScript integration with full type inference
-- **Production Ready**: Battle-tested with comprehensive error handling and debugging
+- **Familiar Syntax**: Write schemas using TypeScript-like interface definitions.
+- **Advanced Conditionals**: Unique runtime property validation and business logic.
+- **Rich Tooling**: Dedicated VS Code extension with comprehensive development support.
+- **Type Integration**: Seamless TypeScript integration with full type inference.
+- **Production Ready**: Battle-tested with comprehensive error handling and debugging.
 
 ### Community and Growth
 
 We're building Reliant Type with transparency and community feedback at its core. We welcome:
 
-- **Real-world usage feedback** and performance insights
-- **Issue reports** with detailed reproduction cases
-- **Feature requests** based on practical development needs
-- **Performance benchmarking** on diverse use cases
-- **Constructive feedback** on API design and developer experience
+- **Real-world usage feedback** and performance insights.
+- **Issue reports** with detailed reproduction cases.
+- **Feature requests** based on practical development needs.
+- **Performance benchmarking** on diverse use cases.
+- **Constructive feedback** on API design and developer experience.
 
 ## API Reference
 
@@ -798,508 +728,3 @@ if (result.success) {
 #### `schema.safeParseUnknownAsync(data)`
 
 Asynchronous safe validation for unknown data types.
-
-```typescript
-const result = await UserSchema.safeParseUnknownAsync(unknownData);
-if (result.success) {
-  console.log("Valid data:", result.data);
-} else {
-  console.error("Validation errors:", result.errors);
-}
-```
-
-### Schema Transformation Operations
-
-#### `Mod.partial(schema)` - Optional Fields
-
-```typescript
-const PartialUserSchema = Mod.partial(UserSchema);
-// Converts all fields to optional
-```
-
-#### `Mod.required(schema)` - Required Fields
-
-```typescript
-const RequiredUserSchema = Mod.required(PartialUserSchema);
-// Makes all fields required
-```
-
-#### `Mod.pick(schema, keys)` - Field Selection
-
-```typescript
-const PublicUserSchema = Mod.pick(UserSchema, ["id", "name", "email"]);
-// Creates schema with only specified fields
-```
-
-#### `Mod.omit(schema, keys)` - Field Exclusion
-
-```typescript
-const SafeUserSchema = Mod.omit(UserSchema, ["password", "internalId"]);
-// Creates schema excluding specified fields
-```
-
-#### `Mod.extend(schema, extension)` - Schema Extension
-
-```typescript
-const ExtendedUserSchema = Mod.extend(UserSchema, {
-  lastLogin: "date?",
-  preferences: {
-    theme: "light|dark",
-  },
-});
-```
-
-#### `Mod.merge(schema1, schema2)` - Schema Merging
-
-```typescript
-const CombinedSchema = Mod.merge(UserSchema, ProfileSchema);
-// Combines two schemas into one
-```
-
-### Available Extensions
-
-ReliantType provides powerful extensions for enhanced functionality:
-
-```typescript
-// Import extensions for advanced features
-export {
-  Smart, // Smart schema inference from samples and TypeScript types
-  When, // Advanced conditional validation builder
-  Live, // Real-time validation for forms and streaming data
-  Docs, // Auto-documentation generation (OpenAPI, TypeScript, etc.)
-  Extensions, // Extension utilities and helpers
-  Quick, // Quick access utilities for common operations
-  TypeScriptGenerator, // TypeScript code generation from schemas
-} from "reliant-type";
-```
-
-#### Smart Inference
-
-```typescript
-import { Smart } from "reliant-type";
-
-// Infer schema from sample data
-const sampleUser = {
-  id: 1,
-  email: "user@example.com",
-  name: "John Doe",
-  tags: ["developer", "typescript"],
-};
-
-const UserSchema = Smart.fromSample(sampleUser);
-// Generates: { id: "positive", email: "email", name: "string", tags: "string[]" }
-```
-
-#### Conditional Builder
-
-```typescript
-import { When } from "reliant-type";
-
-const OrderSchema = Interface({
-  orderType: "pickup|delivery",
-  address: "string?",
-
-  // Advanced conditional validation
-  deliveryFee: When.field("orderType")
-    .is("delivery")
-    .then("number(0,)")
-    .default("number?"),
-});
-```
-
-#### Real-time Validation with Live Utility
-
-The Live utility provides comprehensive real-time validation with full EventEmitter-like interface, data transformation pipelines, and stream control methods. Perfect for forms, streaming data, and reactive applications.
-
-```typescript
-import { Live } from "reliant-type";
-
-const UserSchema = Interface({
-  id: "number",
-  name: "string(2,50)",
-  email: "email",
-  age: "number(18,120)",
-});
-```
-
-##### Live Validator - Real-time Field Validation
-
-```typescript
-// Create live validator for real-time field validation
-const liveValidator = Live.validator(UserSchema);
-
-// Listen for validation changes
-liveValidator.onValidation((result) => {
-  console.log("Validation result:", result.isValid);
-  console.log("Current errors:", result.errors);
-  updateUI(result);
-});
-
-// Validate fields in real-time
-liveValidator.validateField("email", "user@example.com");
-liveValidator.validateField("name", "John Doe");
-
-// Get current validation state
-console.log("Is valid:", liveValidator.isValid);
-console.log("All errors:", liveValidator.errors);
-
-// Validate entire object
-const fullResult = liveValidator.validateAll(userData);
-```
-
-##### Stream Validator - Advanced Stream Processing
-
-The StreamValidator provides a complete EventEmitter-like interface with all standard stream methods:
-
-```typescript
-// Create stream validator
-const streamValidator = Live.stream(UserSchema);
-
-// ===== EVENT EMITTER METHODS =====
-
-// Generic event listeners (.on, .once, .off, .emit)
-streamValidator.on("valid", (data) => {
-  console.log("Valid data received:", data);
-});
-
-streamValidator.once("invalid", (data, errors) => {
-  console.log("First invalid data:", errors);
-});
-
-streamValidator.on("error", (error) => {
-  console.error("Stream error:", error);
-});
-
-// Custom events
-streamValidator.on("custom-event", (message) => {
-  console.log("Custom event:", message);
-});
-
-streamValidator.emit("custom-event", "Hello from stream!");
-
-// Remove listeners
-streamValidator.off("valid", specificListener);
-streamValidator.off("invalid"); // Remove all listeners for event
-```
-
-##### Data Transformation Pipeline
-
-```typescript
-// Build comprehensive data transformation pipeline
-const transformValidator = Live.stream(UserSchema)
-  .transform((data) => {
-    // Add metadata
-    return { ...data, timestamp: Date.now(), source: "api" };
-  })
-  .filter((data) => {
-    // Filter by business rules
-    return data.age >= 21; // Only adults
-  })
-  .map((data) => {
-    // Transform data format
-    return {
-      ...data,
-      name: data.name.toUpperCase(),
-      email: data.email.toLowerCase(),
-    };
-  });
-
-// Listen for pipeline results
-transformValidator.on("valid", (data) => {
-  console.log("Processed data:", data); // Transformed and validated
-});
-
-transformValidator.on("filtered", (data) => {
-  console.log("Data filtered out:", data); // Failed filter conditions
-});
-
-transformValidator.on("invalid", (data, errors) => {
-  console.log("Validation failed after transformation:", errors);
-});
-
-// Process data through pipeline
-transformValidator.validate(rawUserData);
-```
-
-##### Stream Control Methods
-
-```typescript
-// Stream control with pause/resume/destroy
-const controlValidator = Live.stream(UserSchema);
-
-// Pause stream (queues incoming data)
-controlValidator.pause();
-console.log("Stream paused:", controlValidator.paused);
-
-// Data sent while paused gets queued
-controlValidator.validate(userData1); // Queued
-controlValidator.validate(userData2); // Queued
-
-console.log("Queue length:", controlValidator.queueLength);
-
-// Resume stream (processes queued data)
-controlValidator.resume();
-console.log("Stream resumed, queue processed");
-
-// Destroy stream (cleanup and prevent further use)
-controlValidator.on("destroy", () => {
-  console.log("Stream destroyed and cleaned up");
-});
-
-controlValidator.destroy();
-console.log("Stream destroyed:", controlValidator.destroyed);
-```
-
-##### Stream Piping
-
-```typescript
-// Pipe data between stream validators
-const sourceValidator = Live.stream(InputSchema);
-const destinationValidator = Live.stream(OutputSchema);
-
-// Pipe valid data from source to destination
-sourceValidator.pipe(destinationValidator);
-
-// Data flows: source → destination
-sourceValidator.validate(inputData);
-// If valid, automatically sent to destinationValidator
-
-// Chain multiple streams
-const pipeline = sourceValidator
-  .pipe(transformValidator)
-  .pipe(destinationValidator);
-```
-
-##### Form Validator - Advanced Form Integration
-
-```typescript
-// Create form validator with field binding
-const formValidator = Live.form(UserSchema);
-
-// Bind form fields to validator
-formValidator.bindField("email", emailInput);
-formValidator.bindField("name", nameInput);
-formValidator.bindField("age", ageInput);
-
-// Enable automatic validation on input changes
-formValidator.enableAutoValidation();
-
-// Handle form submission
-formValidator.onSubmit((isValid, data, errors) => {
-  if (isValid) {
-    console.log("Form is valid, submitting:", data);
-    submitToAPI(data);
-  } else {
-    console.log("Form has errors:", errors);
-    displayErrors(errors);
-  }
-});
-
-// Manual form validation
-const formResult = formValidator.validateForm();
-console.log("Form valid:", formResult.isValid);
-```
-
-##### Advanced Event Handling
-
-```typescript
-const streamValidator = Live.stream(UserSchema);
-
-// Listen for all validation events
-streamValidator.on("data", (data) => {
-  console.log("Data received for validation:", data);
-});
-
-streamValidator.on("validated", (data, result) => {
-  console.log("Validation completed:", result.isValid);
-});
-
-streamValidator.on("queued", (data) => {
-  console.log("Data queued (stream paused):", data);
-});
-
-streamValidator.on("pause", () => {
-  console.log("Stream paused");
-});
-
-streamValidator.on("resume", () => {
-  console.log("Stream resumed");
-});
-
-// Error handling
-streamValidator.on("error", (error) => {
-  console.error("Stream error:", error.message);
-  // Handle gracefully without crashing
-});
-```
-
-##### Performance and Statistics
-
-```typescript
-// Monitor stream performance
-streamValidator.onStats((stats) => {
-  console.log("Validation Statistics:");
-  console.log(`- Total validated: ${stats.totalValidated}`);
-  console.log(`- Valid count: ${stats.validCount}`);
-  console.log(`- Invalid count: ${stats.invalidCount}`);
-  console.log(`- Error rate: ${(stats.errorRate * 100).toFixed(2)}%`);
-  console.log(`- Running since: ${stats.startTime}`);
-});
-
-// Get current statistics
-const currentStats = streamValidator.getStats();
-console.log("Current performance:", currentStats);
-```
-
-##### Integration with InterfaceSchema
-
-The Live utility is fully synchronized with InterfaceSchema modules, ensuring consistent validation behavior:
-
-```typescript
-const schema = Interface({
-  email: "email",
-  age: "number(18,120)",
-  role: "admin|user|guest",
-});
-
-// Both produce identical validation results
-const interfaceResult = schema.safeParse(userData);
-const liveResult = Live.stream(schema).validate(userData);
-
-// Perfect synchronization guaranteed
-console.log("Results match:", interfaceResult.success === liveResult.isValid);
-```
-
-#### Documentation Generation
-
-```typescript
-import { Docs } from "reliant-type"; //in beta
-
-// Generate OpenAPI specification
-const openApiSpec = Docs.openapi(UserSchema, {
-  title: "User API",
-  version: "1.0.0",
-  servers: ["https://api.example.com"],
-});
-
-// Generate TypeScript definitions
-const typeDefinitions = Docs.typescript(UserSchema, {
-  exportName: "User",
-  namespace: "API",
-});
-```
-
-#### Quick Utilities
-
-```typescript
-import { Quick } from "reliant-type";
-
-// Quick schema inference
-const schema = Quick.fromSample(sampleData);
-
-// Quick conditional validation
-const conditionalField = Quick.when("status").is("active").then("string");
-
-// Quick documentation
-const docs = Quick.docs(schema);
-const typescript = Quick.typescript(schema);
-```
-
-### Validation Configuration
-
-#### Method Chaining
-
-```typescript
-const FlexibleSchema = UserSchema.loose() // Enable automatic type coercion
-  .allowUnknown() // Accept extra properties
-  .min(1) // Set minimum constraints
-  .max(100) // Set maximum constraints
-  .unique() // Require unique array values
-  .pattern(/^[A-Z]/) // Apply regex pattern validation
-  .default("N/A"); // Set default value
-```
-
-## Contributing
-
-By contributing to ReliantType, you help reliant-type to:
-
-- Improve the quality of TypeScript validation
-- Expand the reach of TypeScript in the JavaScript ecosystem
-- Provide a robust and reliable validation solution for developers
-- Foster a community of developers who care about code quality and security
-
-### Development Environment
-
-```bash
-# Repository setup
-git clone https://github.com/Nehonix-Team/reliant-type.git
-cd reliant-type
-
-# Dependency installation
-npm install
-
-# Test suite execution
-npm run test
-
-# Performance benchmarking
-npm run benchmark
-
-# Project build
-npm run build
-```
-
-### Quality Standards
-
-- **TypeScript**: Strict mode with comprehensive type checking
-- **Test Coverage**: 95%+ coverage requirement
-- **Performance**: All benchmarks must pass performance thresholds
-- **Documentation**: Complete JSDoc comments for all public APIs
-- **Code Quality**: ESLint and Prettier configuration compliance
-
-### Contribution Process
-
-1. **Fork** the repository on GitHub
-2. **Create** a feature branch: `git checkout -b feature/enhancement-name`
-3. **Implement** changes with comprehensive test coverage
-4. **Verify** all tests pass: `npm test`
-5. **Validate** performance: `npm run benchmark`
-6. **Commit** changes: `git commit -m 'Add enhancement: description'`
-7. **Push** to branch: `git push origin feature/enhancement-name`
-8. **Submit** a Pull Request with detailed description
-
-### Issue Reporting
-
-For effective issue resolution, please provide:
-
-- **Environment Details**: Reliant Type, TypeScript, and Node.js versions
-- **Reproduction Case**: Minimal code example demonstrating the issue
-- **Expected Behavior**: Clear description of intended functionality
-- **Actual Behavior**: Detailed explanation of observed behavior
-- **Error Information**: Complete error messages and stack traces
-
-## Release History
-
-See [CHANGELOG.md](./CHANGELOG.md) for comprehensive release notes and migration guides.
-
-## License
-
-MIT License - see [LICENSE](./LICENSE) file for complete terms.
-
-## Support Resources
-
-- **Complete Documentation**: [Full documentation](./docs/)
-- **Issue Tracking**: [GitHub Issues](https://github.com/Nehonix-Team/reliant-type/issues)
-- **Community Discussions**: [GitHub Discussions](https://github.com/Nehonix-Team/reliant-type/discussions)
-
----
-
-**Development Status**: Reliant Type is in active development with a focus on production readiness. We maintain transparency about capabilities and limitations while continuously improving based on community feedback and real-world usage patterns.
-
-<div align="center">
-  <p><strong>Built by Nehonix</strong></p>
-  <p>
-    <a href="https://nehonix.space">Website</a> •
-    <a href="https://sdk.nehonix.space">SDK</a> •
-    <a href="https://github.com/Nehonix-Team">GitHub</a>
-  </p>
-</div>