┌─────────────────┐    ┌──────────────────┐    ┌─────────────────┐
│   .tsk Files    │───▶│   TuskLang SDK   │───▶│  Your App/API   │
│                 │    │                  │    │                 │
│ • peanu.tsk     │    │ • Parser         │    │ • Type Safety   │
│ • secrets.tsk   │    │ • @ Operators    │    │ • Hot Reload    │
│ • features.tsk  │    │ • FUJSEN Engine  │    │ • Validation    │
└─────────────────┘    └──────────────────┘    └─────────────────┘
         │                       │                       │
         │              ┌────────▼────────┐              │
         │              │   Integrations  │              │
         │              │                 │              │
         └──────────────│ • Databases     │──────────────┘
                        │ • APIs          │
                        │ • File System   │
                        │ • Environment   │
                        └─────────────────┘

# config.tsk - Write in your preferred syntax
[app]
name: "TuskLang  Demo"
version: @env("VERSION", ".0")

database {
    host: @env("DB_HOST", "localhost")
    port: 5432
    max_connections: @query("SELECT optimal_connections FROM metrics")
}

cache >
    driver: "redis"
    ttl: @env("NODE_ENV") == "production" ? "1h" : "5m"
<

# Real-time configuration that adapts to your data
[features]
enabled: @query("SELECT feature_name FROM features WHERE active = 1")
user_limit: @query("SELECT max_users FROM plan WHERE id = ?", [plan_id])

[scaling]
current_load: @query("SELECT AVG(cpu) FROM metrics WHERE time > NOW() - '5m'")
instances: current_load > 80 ? 10 : 5

# peanut.tsk - Global configuration hub
globals {
    api_version: "v2"
    company: "TuskLang Corp"
    region: @env("AWS_REGION", "us-east-1")
}

# api.tsk - References global config
endpoint: @peanut.get("globals.api_version") + "/users"
region: @peanut.get("globals.region")

# Every @ operator now optimized for .pnt binary format
config: @file("settings.pnt")          # Load binary configs
users: @query("SELECT * FROM users")   # Database queries
api_key: @vault("secret/api/key")     # Secure secrets
cache: @redis("app:cache:main")       # Redis integration
status: @http("GET", "/health")       # HTTP requests
ml_result: @ai("classify", data)      # AI/ML integration

[validation]
email_validator: """
function validate(email) {
    const regex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
    return regex.test(email);
}
"""

[processing]
data_transformer: """
function transform(data) {
    return data.map(item => ({
        ...item,
        timestamp: new Date().toISOString(),
        processed: true
    }));
}
"""

# This isn't just configuration - it's INTELLIGENT INFRASTRUCTURE
app_name: "TuskLang Production"
environment: @env("NODE_ENV", "development")

# Real-time auto-scaling based on actual metrics
scaling {
    current_cpu: @query("SELECT AVG(cpu_percent) FROM metrics WHERE timestamp > NOW() - INTERVAL 5 MINUTE")
    current_memory: @query("SELECT AVG(memory_percent) FROM metrics WHERE timestamp > NOW() - INTERVAL 5 MINUTE")
    
    # Intelligent decisions based on real data
    needed_workers: current_cpu > 80 || current_memory > 85 ? 10 : 5
    scale_up_trigger: current_cpu > 90
}

# Dynamic pricing based on inventory and demand
pricing {
    base_price: 99.99
    current_stock: @query("SELECT quantity FROM inventory WHERE sku = 'PRODUCT_001'")
    demand_factor: @query("SELECT COUNT(*) / 100.0 FROM page_views WHERE product_id = 'PRODUCT_001' AND timestamp > NOW() - INTERVAL 1 HOUR")
    
    # Smart pricing algorithm
    final_price: base_price * (current_stock < 10 ? 1.5 : 1.0) * (1.0 + demand_factor)
}

# Feature flags with A/B testing and machine learning
features {
    # Database-driven feature flags
    new_checkout: @query("SELECT enabled FROM feature_flags WHERE name = 'new_checkout_v2'")
    
    # ML-optimized features that learn from user behavior  
    recommendation_engine: @learn("best_recommendation_algorithm", "collaborative_filtering")
    ui_theme: @learn("optimal_ui_theme", "dark")
    
    # Cached expensive computations
    user_segments: @cache("10m", @query("SELECT user_id, segment FROM user_segmentation"))
}

# Performance monitoring and alerting
monitoring {
    error_rate: @metrics("error_rate_5m", 0.01)
    response_time: @metrics("avg_response_time_ms", 250)
    
    # Auto-alert when things go wrong
    alert_trigger: error_rate > 0.05 || response_time > 1000
    
    # Self-healing configuration
    cache_ttl: response_time > 500 ? "1m" : "5m"
    rate_limit: error_rate > 0.03 ? 50 : 100
}

# Traditional INI-style
[database]
host: "localhost"

# JSON-like objects  
server {
    port: 8080
    workers: 4
}

# XML-inspired
cache >
    driver: "redis"
    ttl: "5m"
<

# Query your database directly - this changes EVERYTHING!
user_limit: @query("SELECT max_users FROM plans WHERE active = 1")
feature_flags: @query("SELECT name, enabled FROM features WHERE user_id = ?", [user_id])
cache_size: @query("SELECT value FROM settings WHERE key = 'cache_size'")

# Real-time pricing based on inventory
product_price: @query("SELECT price * (CASE WHEN stock < 10 THEN 1.5 ELSE 1.0 END) FROM products WHERE sku = ?", ["TSK-001"])

# Auto-scaling based on current load
worker_count: @query("SELECT CEIL(AVG(cpu_usage) / 20) FROM server_metrics WHERE timestamp > NOW() - INTERVAL 5 MINUTE")

# Feature flags with A/B testing
show_new_ui: @query("SELECT enabled FROM ab_tests WHERE test_name = 'new_ui' AND user_segment = ?", [user_segment])

# peanut.tsk - Global configuration accessible everywhere
globals {
    api_key: @env("API_KEY")
    base_url: "https://api.tuskt.sk"
    company: "TuskLang Corp"
}

# main.tsk - Reference globals from anywhere  
api_endpoint: @global("base_url") + "/v2/users"
auth_header: "Bearer " + @global("api_key")

# worker.tsk - Cross-file references
main_config: @file("main.tsk") 
database_config: @file("config/database.tsk")
api_url: main_config.api_endpoint + "/workers"

# Conditional file loading
environment: @env("NODE_ENV", "development")
env_config: @file("config/" + environment + ".tsk")

# Environment variables with intelligent defaults
api_key: @env("API_KEY", "dev-key-12345")
debug: @env("DEBUG", false)

# Date/time operations
created_at: @date("Y-m-d H:i:s")
expires_at: @date("Y-m-d H:i:s", "+7 days")
cache_key: "data_" + @date("YmdHis")

# Intelligent caching - cache expensive operations
user_stats: @cache("5m", @query("SELECT COUNT(*) FROM users"))
api_response: @cache("30s", @http("GET", "https://external-api.com/data"))

# Machine learning optimization
optimal_workers: @optimize("worker_count", 4)
cache_size: @learn("optimal_cache_mb", 512)

# Metrics and monitoring  
response_time: @metrics("avg_response_ms", 150)
error_rate: @metrics("error_percentage", 0.5)

# PHP code execution
server_memory: @php("memory_get_usage(true) / 1024 / 1024")
random_token: @php("bin2hex(random_bytes(16))")

# Smart conditionals
environment: @env("NODE_ENV", "development")
workers: environment == "production" ? 8 : 2
log_level: environment == "production" ? "error" : "debug"
ssl_enabled: environment != "development"

[payment]
process_fujsen: """
function process(amount, recipient) {
    if (amount <= 0) throw new Error("Invalid amount");
    
    return {
        success: true,
        transactionId: 'tx_' + Date.now(),
        amount: amount,
        recipient: recipient,
        fee: amount * 0.025
    };
}
"""

[player]
health: 100
speed: 5.0

[combat]
damage_calc_fujsen: """
function calculateDamage(attack, defense, weapon) {
    return Math.max(1, (attack * weapon.power) - (defense * 0.1));
}
"""

[deploy]
environment: @env("DEPLOY_ENV", "staging")
region: @env("AWS_REGION", "us-west-2")
instance_count: @query("SELECT COUNT(*) FROM instances WHERE region = ?", $region)

[pipeline]
build_fujsen: """
function getBuildSteps(environment) {
    const steps = ['test', 'build'];
    if (environment === 'production') {
        steps.push('security-scan', 'performance-test');
    }
    return steps;
}
"""

[services]
auth_service: @service_discovery.tsk.get("auth", "endpoint")
user_service: @service_discovery.tsk.get("user", "endpoint")  
payment_service: @service_discovery.tsk.get("payment", "endpoint")

[database]
connection_pool: @query("SELECT optimal_pool_size FROM performance_metrics LIMIT 1")