effect-start 0.23.1 → 0.26.0

package/dist/console/Simulation.js

@@ -1,633 +0,0 @@
-import * as Data from "effect/Data";
-import * as Duration from "effect/Duration";
-import * as Effect from "effect/Effect";
-import * as Layer from "effect/Layer";
-import * as Metric from "effect/Metric";
-import * as MetricBoundaries from "effect/MetricBoundaries";
-import * as Random from "effect/Random";
-import * as Schedule from "effect/Schedule";
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-const pick = (arr) => Random.nextIntBetween(0, arr.length).pipe(Effect.map((i) => arr[i]));
-const randomMs = (min, max) => Random.nextIntBetween(min, max).pipe(Effect.map((ms) => Duration.millis(ms)));
-const maybe = (pct, op) => Effect.gen(function* () {
-    if ((yield* Random.nextIntBetween(0, 100)) < pct)
-        yield* op;
-});
-// ---------------------------------------------------------------------------
-// Metrics
-// ---------------------------------------------------------------------------
-const httpRequestsTotal = Metric.counter("http.requests.total");
-const httpRequestDuration = Metric.histogram("http.request.duration_ms", MetricBoundaries.linear({ start: 0, width: 50, count: 20 }));
-const activeConnections = Metric.gauge("http.active_connections");
-const dbQueryDuration = Metric.histogram("db.query.duration_ms", MetricBoundaries.linear({ start: 0, width: 10, count: 25 }));
-const dbPoolSize = Metric.gauge("db.pool.active");
-const cacheHits = Metric.counter("cache.hits");
-const cacheMisses = Metric.counter("cache.misses");
-const queueDepth = Metric.gauge("queue.depth");
-const eventCount = Metric.counter("events.processed");
-const retryCount = Metric.counter("retry.total");
-const circuitBreakerTrips = Metric.counter("circuit_breaker.trips");
-const rateLimitRejections = Metric.counter("rate_limit.rejections");
-const serializationDuration = Metric.histogram("serialization.duration_ms", MetricBoundaries.linear({ start: 0, width: 5, count: 15 }));
-// ---------------------------------------------------------------------------
-// Simulated operations
-// ---------------------------------------------------------------------------
-const routes = [
-    { method: "GET", path: "/api/users", handler: "UserController.list" },
-    { method: "GET", path: "/api/users/:id", handler: "UserController.get" },
-    { method: "POST", path: "/api/users", handler: "UserController.create" },
-    { method: "PUT", path: "/api/users/:id", handler: "UserController.update" },
-    { method: "DELETE", path: "/api/users/:id", handler: "UserController.delete" },
-    { method: "GET", path: "/api/products", handler: "ProductController.list" },
-    { method: "GET", path: "/api/products/:id", handler: "ProductController.get" },
-    { method: "POST", path: "/api/orders", handler: "OrderController.create" },
-    { method: "GET", path: "/api/orders/:id", handler: "OrderController.get" },
-    { method: "PATCH", path: "/api/orders/:id/status", handler: "OrderController.updateStatus" },
-    { method: "POST", path: "/api/auth/login", handler: "AuthController.login" },
-    { method: "POST", path: "/api/auth/refresh", handler: "AuthController.refresh" },
-    { method: "POST", path: "/api/auth/logout", handler: "AuthController.logout" },
-    { method: "GET", path: "/api/search", handler: "SearchController.query" },
-    { method: "GET", path: "/api/analytics/dashboard", handler: "AnalyticsController.dashboard" },
-    { method: "POST", path: "/api/notifications/send", handler: "NotificationController.send" },
-    { method: "POST", path: "/api/uploads/image", handler: "UploadController.image" },
-    { method: "GET", path: "/api/health", handler: "HealthController.check" },
-    { method: "GET", path: "/api/config", handler: "ConfigController.get" },
-    { method: "POST", path: "/api/webhooks/stripe", handler: "WebhookController.stripe" },
-];
-const dbQueries = [
-    "SELECT * FROM users WHERE id = $1",
-    "SELECT * FROM users ORDER BY created_at DESC LIMIT 20",
-    "INSERT INTO users (name, email) VALUES ($1, $2) RETURNING *",
-    "UPDATE users SET name = $1 WHERE id = $2",
-    "SELECT p.*, c.name AS category FROM products p JOIN categories c ON p.category_id = c.id",
-    "SELECT * FROM orders WHERE user_id = $1 ORDER BY created_at DESC",
-    "INSERT INTO orders (user_id, total, status) VALUES ($1, $2, $3)",
-    "SELECT u.*, COUNT(o.id) AS order_count FROM users u LEFT JOIN orders o ON u.id = o.id GROUP BY u.id",
-    "DELETE FROM sessions WHERE expires_at < NOW()",
-    "SELECT * FROM products WHERE tsv @@ plainto_tsquery($1) LIMIT 50",
-    "SELECT o.*, json_agg(oi.*) AS items FROM orders o JOIN order_items oi ON o.id = oi.order_id WHERE o.id = $1 GROUP BY o.id",
-    "WITH ranked AS (SELECT *, ROW_NUMBER() OVER (PARTITION BY category_id ORDER BY sales DESC) rn FROM products) SELECT * FROM ranked WHERE rn <= 5",
-    "UPDATE inventory SET quantity = quantity - $1 WHERE product_id = $2 AND quantity >= $1 RETURNING quantity",
-];
-const cacheKeys = [
-    "user:profile:42",
-    "user:profile:108",
-    "product:listing:page:1",
-    "product:detail:77",
-    "session:abc123",
-    "rate_limit:192.168.1.1",
-    "search:results:shoes",
-    "config:feature_flags",
-    "analytics:dashboard:daily",
-    "inventory:stock:sku_4421",
-    "cart:user:42",
-];
-const errorMessages = [
-    "connection refused: upstream timeout after 30s",
-    "UNIQUE constraint failed: users.email",
-    "rate limit exceeded for client 10.0.3.44",
-    "invalid JWT: token expired at 2025-12-01T00:00:00Z",
-    "payment gateway returned 502",
-    "deadlock detected on table orders",
-    "request body exceeds 10MB limit",
-    "foreign key constraint: order references missing user",
-    "TLS handshake timeout with payment-service:443",
-    "DNS resolution failed for analytics.internal.svc",
-];
-// ---------------------------------------------------------------------------
-// Errors
-// ---------------------------------------------------------------------------
-class DatabaseError extends Data.TaggedError("DatabaseError") {
-}
-class AuthenticationError extends Data.TaggedError("AuthenticationError") {
-}
-class ExternalServiceError extends Data.TaggedError("ExternalServiceError") {
-}
-class TimeoutError extends Data.TaggedError("TimeoutError") {
-}
-class ValidationError extends Data.TaggedError("ValidationError") {
-}
-class TaskError extends Data.TaggedError("TaskError") {
-}
-class HttpError extends Data.TaggedError("HttpError") {
-}
-class RateLimitError extends Data.TaggedError("RateLimitError") {
-}
-class CircuitBreakerError extends Data.TaggedError("CircuitBreakerError") {
-}
-// ---------------------------------------------------------------------------
-// Leaf-level spans
-// ---------------------------------------------------------------------------
-const simulateDnsResolve = Effect.gen(function* () {
-    const hosts = [
-        "db-primary.internal",
-        "cache-01.internal",
-        "payment-service.prod",
-        "queue.internal",
-        "analytics.internal.svc",
-    ];
-    const host = yield* pick(hosts);
-    yield* Effect.annotateCurrentSpan("dns.host", host);
-    yield* Effect.sleep(yield* randomMs(0, 5));
-    if ((yield* Random.nextIntBetween(0, 100)) < 2) {
-        return yield* Effect.fail(new TimeoutError({ operation: `dns.resolve(${host})`, durationMs: 5000 }));
-    }
-}).pipe(Effect.withSpan("dns.resolve"));
-const simulateTlsHandshake = Effect.gen(function* () {
-    yield* Effect.sleep(yield* randomMs(2, 20));
-    yield* Effect.annotateCurrentSpan("tls.version", "1.3");
-    yield* Effect.annotateCurrentSpan("tls.cipher", "TLS_AES_256_GCM_SHA384");
-    if ((yield* Random.nextIntBetween(0, 100)) < 1) {
-        return yield* Effect.fail(new TimeoutError({ operation: "tls.handshake", durationMs: 10000 }));
-    }
-}).pipe(Effect.withSpan("tls.handshake"));
-const simulateConnectionPoolAcquire = Effect.gen(function* () {
-    const pool = yield* Random.nextIntBetween(1, 20);
-    const maxPool = 20;
-    yield* Effect.annotateCurrentSpan("pool.active", pool);
-    yield* Effect.annotateCurrentSpan("pool.max", maxPool);
-    yield* dbPoolSize.pipe(Metric.set(pool));
-    yield* Effect.sleep(yield* randomMs(0, pool > 15 ? 50 : 5));
-    if (pool >= 19 && (yield* Random.nextIntBetween(0, 100)) < 30) {
-        return yield* Effect.die(new DatabaseError({ query: "", reason: "connection pool exhausted" }));
-    }
-}).pipe(Effect.withSpan("db.pool.acquire"));
-const simulateConnectionPoolRelease = Effect.gen(function* () {
-    yield* Effect.sleep(yield* randomMs(0, 1));
-}).pipe(Effect.withSpan("db.pool.release"));
-const simulateQueryParse = Effect.gen(function* () {
-    yield* Effect.sleep(yield* randomMs(0, 3));
-    yield* Effect.annotateCurrentSpan("db.parse.cached", (yield* Random.nextIntBetween(0, 100)) < 80);
-}).pipe(Effect.withSpan("db.query.parse"));
-const simulateQueryExecute = Effect.gen(function* () {
-    const query = yield* pick(dbQueries);
-    const delay = yield* randomMs(1, 80);
-    yield* Effect.annotateCurrentSpan("db.statement", query);
-    yield* Metric.update(dbQueryDuration, Math.round(Duration.toMillis(delay)));
-    yield* Effect.sleep(delay);
-    const roll = yield* Random.nextIntBetween(0, 100);
-    if (roll < 2) {
-        return yield* Effect.fail(new DatabaseError({ query, reason: "deadlock detected on table orders" }));
-    }
-    if (roll < 4) {
-        return yield* Effect.fail(new TimeoutError({
-            operation: "db.query.execute",
-            durationMs: Math.round(Duration.toMillis(delay)),
-        }));
-    }
-}).pipe(Effect.withSpan("db.query.execute"));
-const simulateResultDeserialization = Effect.gen(function* () {
-    const rowCount = yield* Random.nextIntBetween(0, 500);
-    yield* Effect.annotateCurrentSpan("db.rows", rowCount);
-    yield* Effect.sleep(yield* randomMs(0, rowCount > 100 ? 15 : 3));
-}).pipe(Effect.withSpan("db.result.deserialize"));
-const simulateDbQuery = Effect.gen(function* () {
-    yield* simulateConnectionPoolAcquire;
-    yield* simulateQueryParse;
-    yield* simulateQueryExecute;
-    yield* simulateResultDeserialization;
-    yield* simulateConnectionPoolRelease;
-}).pipe(Effect.withSpan("db.query"));
-const simulateCacheSerialize = Effect.gen(function* () {
-    const ms = yield* Random.nextIntBetween(0, 5);
-    yield* Metric.update(serializationDuration, ms);
-    yield* Effect.sleep(Duration.millis(ms));
-}).pipe(Effect.withSpan("cache.serialize"));
-const simulateCacheDeserialize = Effect.gen(function* () {
-    const ms = yield* Random.nextIntBetween(0, 4);
-    yield* Metric.update(serializationDuration, ms);
-    yield* Effect.sleep(Duration.millis(ms));
-}).pipe(Effect.withSpan("cache.deserialize"));
-const simulateCache = Effect.gen(function* () {
-    const key = yield* pick(cacheKeys);
-    const hit = (yield* Random.nextIntBetween(0, 100)) < 75;
-    yield* Effect.annotateCurrentSpan("cache.key", key);
-    yield* Effect.annotateCurrentSpan("cache.hit", hit);
-    yield* Effect.sleep(yield* randomMs(0, 3));
-    if (hit) {
-        yield* Metric.increment(cacheHits);
-        yield* simulateCacheDeserialize;
-        yield* Effect.logDebug(`cache hit: ${key}`);
-    }
-    else {
-        yield* Metric.increment(cacheMisses);
-        yield* Effect.logDebug(`cache miss: ${key}`);
-    }
-}).pipe(Effect.withSpan("cache.lookup"));
-const simulateTokenDecode = Effect.gen(function* () {
-    yield* Effect.sleep(yield* randomMs(0, 2));
-    yield* Effect.annotateCurrentSpan("jwt.alg", "RS256");
-}).pipe(Effect.withSpan("jwt.decode"));
-const simulateTokenVerify = Effect.gen(function* () {
-    yield* Effect.sleep(yield* randomMs(1, 8));
-    const roll = yield* Random.nextIntBetween(0, 100);
-    if (roll < 3) {
-        return yield* Effect.fail(new AuthenticationError({ reason: "JWT expired at 2025-12-01T00:00:00Z" }));
-    }
-    if (roll < 5) {
-        return yield* Effect.fail(new AuthenticationError({
-            reason: "invalid signature",
-            userId: "user_" + (yield* Random.nextIntBetween(100, 999)),
-        }));
-    }
-}).pipe(Effect.withSpan("jwt.verify"));
-const simulatePermissionCheck = Effect.gen(function* () {
-    const roles = ["admin", "editor", "viewer", "moderator"];
-    const role = yield* pick(roles);
-    yield* Effect.annotateCurrentSpan("auth.role", role);
-    yield* Effect.sleep(yield* randomMs(0, 3));
-    if ((yield* Random.nextIntBetween(0, 100)) < 2) {
-        return yield* Effect.fail(new AuthenticationError({ reason: `insufficient permissions for role: ${role}` }));
-    }
-}).pipe(Effect.withSpan("auth.permission_check"));
-const simulateAuth = Effect.gen(function* () {
-    yield* simulateTokenDecode;
-    yield* simulateTokenVerify;
-    yield* simulatePermissionCheck;
-    yield* Effect.logDebug("token validated");
-}).pipe(Effect.withSpan("auth.validate"));
-const simulateRateLimit = Effect.gen(function* () {
-    const ips = ["10.0.3.44", "192.168.1.1", "172.16.0.55", "10.0.7.12", "203.0.113.42"];
-    const ip = yield* pick(ips);
-    const remaining = yield* Random.nextIntBetween(0, 100);
-    yield* Effect.annotateCurrentSpan("rate_limit.client_ip", ip);
-    yield* Effect.annotateCurrentSpan("rate_limit.remaining", remaining);
-    yield* Effect.sleep(yield* randomMs(0, 2));
-    if (remaining < 3) {
-        yield* Metric.increment(rateLimitRejections);
-        yield* Effect.logWarning(`rate limit near threshold for ${ip}`);
-        if ((yield* Random.nextIntBetween(0, 100)) < 40) {
-            return yield* Effect.fail(new RateLimitError({ clientIp: ip, limit: 100 }));
-        }
-    }
-}).pipe(Effect.withSpan("middleware.rate_limit"));
-const simulateCors = Effect.gen(function* () {
-    const origins = [
-        "https://app.example.com",
-        "https://admin.example.com",
-        "https://mobile.example.com",
-        "null",
-    ];
-    const origin = yield* pick(origins);
-    yield* Effect.annotateCurrentSpan("cors.origin", origin);
-    yield* Effect.sleep(yield* randomMs(0, 1));
-    if (origin === "null") {
-        yield* Effect.logWarning("CORS: rejected null origin");
-    }
-}).pipe(Effect.withSpan("middleware.cors"));
-const simulateRequestParsing = Effect.gen(function* () {
-    const contentTypes = [
-        "application/json",
-        "multipart/form-data",
-        "application/x-www-form-urlencoded",
-        "text/plain",
-    ];
-    const ct = yield* pick(contentTypes);
-    yield* Effect.annotateCurrentSpan("http.content_type", ct);
-    const bodySize = yield* Random.nextIntBetween(0, 50000);
-    yield* Effect.annotateCurrentSpan("http.body_size", bodySize);
-    yield* Effect.sleep(yield* randomMs(0, bodySize > 10000 ? 15 : 3));
-    if (bodySize > 40000) {
-        return yield* Effect.fail(new ValidationError({ field: "body", message: "request body exceeds 10MB limit" }));
-    }
-    if ((yield* Random.nextIntBetween(0, 100)) < 3) {
-        return yield* Effect.fail(new ValidationError({ field: "body", message: "malformed JSON at position 42" }));
-    }
-}).pipe(Effect.withSpan("http.parse_body"));
-const simulateInputValidation = Effect.gen(function* () {
-    yield* Effect.sleep(yield* randomMs(0, 3));
-    const fields = ["email", "name", "amount", "quantity", "phone", "address.zip"];
-    if ((yield* Random.nextIntBetween(0, 100)) < 5) {
-        const field = yield* pick(fields);
-        return yield* Effect.fail(new ValidationError({ field, message: `invalid format for ${field}` }));
-    }
-}).pipe(Effect.withSpan("validation.input"));
-const simulateResponseSerialization = Effect.gen(function* () {
-    const formats = ["json", "msgpack", "protobuf"];
-    const format = yield* pick(formats);
-    yield* Effect.annotateCurrentSpan("serialization.format", format);
-    const ms = yield* Random.nextIntBetween(0, 10);
-    yield* Metric.update(serializationDuration, ms);
-    yield* Effect.sleep(Duration.millis(ms));
-}).pipe(Effect.withSpan("http.serialize_response"));
-const simulateCompression = Effect.gen(function* () {
-    const algos = ["gzip", "br", "none"];
-    const algo = yield* pick(algos);
-    yield* Effect.annotateCurrentSpan("compression.algorithm", algo);
-    yield* Effect.sleep(yield* randomMs(0, algo === "none" ? 1 : 8));
-}).pipe(Effect.withSpan("http.compress"));
-const simulateAccessLog = Effect.gen(function* () {
-    yield* Effect.sleep(yield* randomMs(0, 1));
-}).pipe(Effect.withSpan("middleware.access_log"));
-// ---------------------------------------------------------------------------
-// Composite sub-operations with deep nesting
-// ---------------------------------------------------------------------------
-const simulateCircuitBreaker = (inner, service) => Effect.gen(function* () {
-    const failures = yield* Random.nextIntBetween(0, 10);
-    yield* Effect.annotateCurrentSpan("circuit_breaker.service", service);
-    yield* Effect.annotateCurrentSpan("circuit_breaker.failure_count", failures);
-    if (failures >= 8) {
-        yield* Metric.increment(circuitBreakerTrips);
-        yield* Effect.logWarning(`circuit breaker OPEN for ${service}`);
-        return yield* Effect.fail(new CircuitBreakerError({ service, failureCount: failures }));
-    }
-    yield* inner;
-}).pipe(Effect.withSpan("circuit_breaker"));
-const simulateRetry = (inner, opName) => Effect.gen(function* () {
-    const maxRetries = 3;
-    let attempt = 0;
-    let succeeded = false;
-    while (attempt < maxRetries && !succeeded) {
-        attempt++;
-        yield* Effect.annotateCurrentSpan("retry.attempt", attempt);
-        const result = yield* inner.pipe(Effect.map(() => true), Effect.catchAll((e) => {
-            if (attempt < maxRetries) {
-                return Effect.gen(function* () {
-                    yield* Metric.increment(retryCount);
-                    yield* Effect.logWarning(`${opName} attempt ${attempt} failed, retrying`);
-                    yield* Effect.sleep(yield* randomMs(10, 50 * attempt));
-                    return false;
-                });
-            }
-            return Effect.fail(e);
-        }));
-        succeeded = result;
-    }
-}).pipe(Effect.withSpan("retry"));
-const simulateExternalCall = Effect.gen(function* () {
-    const services = [
-        "payment-service",
-        "email-service",
-        "notification-service",
-        "inventory-service",
-        "shipping-service",
-        "tax-service",
-    ];
-    const service = yield* pick(services);
-    yield* Effect.annotateCurrentSpan("peer.service", service);
-    yield* simulateDnsResolve;
-    yield* simulateTlsHandshake;
-    const delay = yield* randomMs(10, 300);
-    yield* Effect.annotateCurrentSpan("http.outgoing.duration_ms", Math.round(Duration.toMillis(delay)));
-    yield* Effect.sleep(delay);
-    const roll = yield* Random.nextIntBetween(0, 100);
-    if (roll < 4) {
-        yield* Effect.logError(`${service} responded with 503`);
-        return yield* Effect.fail(new ExternalServiceError({ service, statusCode: 503, reason: "service unavailable" }));
-    }
-    if (roll < 6) {
-        yield* Effect.logError(`${service} timed out after ${Math.round(Duration.toMillis(delay))}ms`);
-        return yield* Effect.fail(new TimeoutError({
-            operation: `${service} call`,
-            durationMs: Math.round(Duration.toMillis(delay)),
-        }));
-    }
-    if (roll < 8) {
-        yield* Effect.logError(`${service} responded with 502`);
-        return yield* Effect.fail(new ExternalServiceError({ service, statusCode: 502, reason: "bad gateway" }));
-    }
-}).pipe(Effect.withSpan("http.outgoing"));
-const simulateExternalCallWithResilience = Effect.gen(function* () {
-    const service = yield* pick([
-        "payment-service",
-        "email-service",
-        "notification-service",
-        "inventory-service",
-    ]);
-    yield* simulateCircuitBreaker(simulateRetry(simulateExternalCall, `external.${service}`), service);
-}).pipe(Effect.withSpan("external.resilient_call"));
-const simulateSearchQuery = Effect.gen(function* () {
-    const terms = ["shoes", "laptop", "organic food", "headphones", "gift ideas"];
-    const term = yield* pick(terms);
-    yield* Effect.annotateCurrentSpan("search.query", term);
-    yield* simulateCache;
-    yield* Effect.gen(function* () {
-        yield* Effect.sleep(yield* randomMs(5, 40));
-        yield* Effect.annotateCurrentSpan("search.engine", "elasticsearch");
-        yield* Effect.annotateCurrentSpan("search.index", "products_v3");
-        const hits = yield* Random.nextIntBetween(0, 200);
-        yield* Effect.annotateCurrentSpan("search.hits", hits);
-    }).pipe(Effect.withSpan("search.execute"));
-    yield* Effect.gen(function* () {
-        yield* Effect.sleep(yield* randomMs(1, 10));
-        yield* Effect.annotateCurrentSpan("search.boost", "relevance+recency");
-    }).pipe(Effect.withSpan("search.rank"));
-    yield* Effect.gen(function* () {
-        yield* Effect.sleep(yield* randomMs(0, 5));
-    }).pipe(Effect.withSpan("search.highlight"));
-}).pipe(Effect.withSpan("search.pipeline"));
-const simulateFileUpload = Effect.gen(function* () {
-    const fileSize = yield* Random.nextIntBetween(1000, 5_000_000);
-    yield* Effect.annotateCurrentSpan("upload.size_bytes", fileSize);
-    yield* Effect.gen(function* () {
-        yield* Effect.sleep(yield* randomMs(1, 10));
-        const types = ["image/jpeg", "image/png", "application/pdf", "image/webp"];
-        const mime = yield* pick(types);
-        yield* Effect.annotateCurrentSpan("upload.mime", mime);
-        if ((yield* Random.nextIntBetween(0, 100)) < 3) {
-            return yield* Effect.fail(new ValidationError({ field: "file", message: "unsupported mime type" }));
-        }
-    }).pipe(Effect.withSpan("upload.validate_mime"));
-    yield* Effect.gen(function* () {
-        yield* Effect.sleep(yield* randomMs(0, 5));
-    }).pipe(Effect.withSpan("upload.virus_scan"));
-    yield* Effect.gen(function* () {
-        yield* Effect.sleep(yield* randomMs(5, 50));
-        yield* Effect.annotateCurrentSpan("upload.bucket", "user-uploads-prod");
-    }).pipe(Effect.withSpan("upload.store_s3"));
-    yield* Effect.gen(function* () {
-        yield* simulateDbQuery;
-    }).pipe(Effect.withSpan("upload.persist_metadata"));
-}).pipe(Effect.withSpan("upload.pipeline"));
-const simulateOrderWorkflow = Effect.gen(function* () {
-    yield* Effect.annotateCurrentSpan("order.workflow", "create");
-    yield* simulateInputValidation;
-    yield* Effect.gen(function* () {
-        yield* simulateDbQuery;
-        yield* Effect.sleep(yield* randomMs(1, 10));
-    }).pipe(Effect.withSpan("order.check_inventory"));
-    yield* Effect.gen(function* () {
-        yield* simulateExternalCallWithResilience;
-    }).pipe(Effect.withSpan("order.process_payment"));
-    yield* Effect.gen(function* () {
-        yield* simulateDbQuery;
-    }).pipe(Effect.withSpan("order.persist"));
-    yield* Effect.gen(function* () {
-        yield* simulateCache;
-        yield* simulateCacheSerialize;
-    }).pipe(Effect.withSpan("order.invalidate_cache"));
-    yield* Effect.gen(function* () {
-        yield* Effect.sleep(yield* randomMs(1, 10));
-        yield* Effect.logInfo("order confirmation email queued");
-    }).pipe(Effect.withSpan("order.queue_notification"));
-}).pipe(Effect.withSpan("order.workflow"));
-const simulateAnalyticsPipeline = Effect.gen(function* () {
-    yield* Effect.gen(function* () {
-        yield* simulateDbQuery;
-        yield* simulateDbQuery;
-    }).pipe(Effect.withSpan("analytics.fetch_raw"));
-    yield* Effect.gen(function* () {
-        yield* Effect.sleep(yield* randomMs(5, 30));
-        yield* Effect.annotateCurrentSpan("analytics.aggregation", "time_series");
-    }).pipe(Effect.withSpan("analytics.aggregate"));
-    yield* Effect.gen(function* () {
-        yield* simulateCache;
-    }).pipe(Effect.withSpan("analytics.cache_result"));
-    yield* Effect.gen(function* () {
-        yield* Effect.sleep(yield* randomMs(2, 15));
-        yield* Effect.annotateCurrentSpan("analytics.format", "dashboard_v2");
-    }).pipe(Effect.withSpan("analytics.transform"));
-}).pipe(Effect.withSpan("analytics.pipeline"));
-// ---------------------------------------------------------------------------
-// Background tasks (also deeper now)
-// ---------------------------------------------------------------------------
-const simulateBackgroundTask = Effect.gen(function* () {
-    const tasks = [
-        "process-webhook",
-        "send-email",
-        "generate-report",
-        "sync-inventory",
-        "cleanup-sessions",
-        "rebuild-search-index",
-        "process-refund",
-        "generate-invoice-pdf",
-        "sync-crm",
-    ];
-    const task = yield* pick(tasks);
-    yield* Effect.logInfo(`starting background task: ${task}`);
-    yield* Effect.gen(function* () {
-        yield* Effect.sleep(yield* randomMs(0, 5));
-        yield* Effect.annotateCurrentSpan("task.priority", yield* pick(["low", "normal", "high", "critical"]));
-    }).pipe(Effect.withSpan("task.dequeue"));
-    yield* Effect.gen(function* () {
-        yield* simulateDbQuery;
-    }).pipe(Effect.withSpan("task.load_context"));
-    yield* Effect.gen(function* () {
-        yield* Effect.sleep(yield* randomMs(20, 300));
-        const roll = yield* Random.nextIntBetween(0, 100);
-        if (roll < 4) {
-            return yield* Effect.fail(new TaskError({ task, reason: "execution exceeded 30s deadline" }));
-        }
-        if (roll < 7) {
-            const err = yield* pick(errorMessages);
-            yield* Effect.logError(`task ${task} failed: ${err}`);
-            return yield* Effect.fail(new TaskError({ task, reason: err }));
-        }
-        if (roll < 9) {
-            return yield* Effect.die(new TaskError({ task, reason: "out of memory" }));
-        }
-    }).pipe(Effect.withSpan("task.execute"));
-    yield* maybe(60, Effect.gen(function* () {
-        yield* simulateExternalCall;
-    }).pipe(Effect.withSpan("task.external_dependency")));
-    yield* Effect.gen(function* () {
-        yield* simulateDbQuery;
-    }).pipe(Effect.withSpan("task.persist_result"));
-    yield* Effect.gen(function* () {
-        yield* Effect.sleep(yield* randomMs(0, 3));
-    }).pipe(Effect.withSpan("task.ack"));
-    yield* Metric.increment(eventCount);
-    yield* Effect.logInfo(`completed background task: ${task}`);
-}).pipe(Effect.withSpan("task.background"));
-// ---------------------------------------------------------------------------
-// Simulate a single HTTP request (deep middleware + handler pipeline)
-// ---------------------------------------------------------------------------
-const simulateRequest = Effect.gen(function* () {
-    const route = yield* pick(routes);
-    const statusCodes = [200, 200, 200, 200, 200, 201, 204, 301, 400, 401, 404, 500];
-    yield* Metric.increment(httpRequestsTotal);
-    yield* Metric.increment(activeConnections);
-    const result = yield* Effect.gen(function* () {
-        yield* Effect.annotateCurrentSpan("http.method", route.method);
-        yield* Effect.annotateCurrentSpan("http.route", route.path);
-        yield* Effect.annotateCurrentSpan("handler", route.handler);
-        // middleware chain
-        yield* simulateAccessLog;
-        yield* simulateCors;
-        yield* simulateRateLimit;
-        yield* simulateRequestParsing;
-        // auth (most routes)
-        yield* maybe(70, simulateAuth);
-        // handler body — pick a complex workflow or simple CRUD based on the route
-        const handler = route.handler;
-        if (handler === "OrderController.create" || handler === "OrderController.updateStatus") {
-            yield* simulateOrderWorkflow;
-        }
-        else if (handler === "SearchController.query") {
-            yield* simulateSearchQuery;
-        }
-        else if (handler === "UploadController.image") {
-            yield* simulateFileUpload;
-        }
-        else if (handler === "AnalyticsController.dashboard") {
-            yield* simulateAnalyticsPipeline;
-        }
-        else if (handler === "WebhookController.stripe") {
-            yield* simulateInputValidation;
-            yield* simulateExternalCallWithResilience;
-            yield* simulateDbQuery;
-        }
-        else {
-            // standard CRUD
-            yield* maybe(50, simulateCache);
-            yield* simulateDbQuery;
-            yield* maybe(25, simulateExternalCall);
-            yield* maybe(30, simulateDbQuery); // secondary query
-        }
-        // response pipeline
-        yield* simulateResponseSerialization;
-        yield* maybe(40, simulateCompression);
-        const status = yield* pick(statusCodes);
-        yield* Effect.annotateCurrentSpan("http.status_code", status);
-        if (status >= 500) {
-            const err = yield* pick(errorMessages);
-            yield* Effect.logError(`${route.method} ${route.path} → ${status}: ${err}`);
-            return yield* Effect.fail(new HttpError({
-                method: route.method,
-                path: route.path,
-                statusCode: status,
-                message: err,
-            }));
-        }
-        if (status >= 400) {
-            yield* Effect.logWarning(`${route.method} ${route.path} → ${status}`);
-        }
-        else {
-            yield* Effect.logInfo(`${route.method} ${route.path} → ${status}`);
-        }
-        return status;
-    }).pipe(Effect.withSpan(`${route.method} ${route.path}`));
-    yield* activeConnections.pipe(Metric.set(0));
-    const durationMs = yield* Random.nextIntBetween(5, 500);
-    yield* Metric.update(httpRequestDuration, durationMs);
-    return result;
-});
-// ---------------------------------------------------------------------------
-// Simulation loops
-// ---------------------------------------------------------------------------
-const requestLoop = Effect.gen(function* () {
-    yield* Effect.logInfo("simulation: request loop started");
-    yield* Effect.schedule(Effect.gen(function* () {
-        const burst = yield* Random.nextIntBetween(1, 4);
-        yield* Effect.forEach(Array.from({ length: burst }, (_, i) => i), () => simulateRequest.pipe(Effect.fork), { concurrency: "unbounded" });
-    }), Schedule.jittered(Schedule.spaced("500 millis")));
-});
-const backgroundLoop = Effect.gen(function* () {
-    yield* Effect.logInfo("simulation: background task loop started");
-    yield* Effect.schedule(Effect.gen(function* () {
-        yield* Effect.fork(simulateBackgroundTask);
-        const depth = yield* Random.nextIntBetween(0, 25);
-        yield* queueDepth.pipe(Metric.set(depth));
-    }), Schedule.jittered(Schedule.spaced("2 seconds")));
-});
-// ---------------------------------------------------------------------------
-// Public API
-// ---------------------------------------------------------------------------
-export const layer = Layer.scopedDiscard(Effect.gen(function* () {
-    yield* Effect.logInfo("simulation layer starting");
-    yield* Effect.forkScoped(requestLoop);
-    yield* Effect.forkScoped(backgroundLoop);
-    yield* Effect.logInfo("simulation layer ready");
-}));

package/dist/console/index.d.ts

@@ -1,3 +0,0 @@
-export * as Console from "./Console.ts";
-export * as ConsoleStore from "./ConsoleStore.ts";
-export * as Simulation from "./Simulation.ts";

package/dist/console/index.js

@@ -1,3 +0,0 @@
-export * as Console from "./Console.js";
-export * as ConsoleStore from "./ConsoleStore.js";
-export * as Simulation from "./Simulation.js";

package/dist/console/routes/errors/route.d.ts

@@ -1,10 +0,0 @@
-import * as Stream from "effect/Stream";
-import * as Route from "../../../Route.ts";
-declare const _default: import("../../../RouteMount.ts").RouteMount.Builder<{}, [Route.Route.Route<{
-    method: "GET";
-    format: "html";
-}, {}, string, never, never>, Route.Route.Route<{
-    method: "GET";
-    format: "text";
-}, {}, Stream.Stream<string, never, never>, never, never>]>;
-export default _default;