effect-start 0.23.0 → 0.25.0

package/dist/console/Simulation.js

@@ -1,633 +1,784 @@
-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";
+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;
-});
+
+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 }));
+
+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 routes = /** @type {const} */ [
+  { 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",
-];
+  "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",
-];
+  "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",
-];
+  "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") {
-}
+
+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 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"));
+  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 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"));
+  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"));
+  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 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 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"));
+  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 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 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 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"));
+  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"));
+  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 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"));
+  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 }));
-        }
+  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"));
+  }
+}).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 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 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"));
+  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 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 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"));
+  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);
+
+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* 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;
+    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;
+      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"));
+  }).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 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 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 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 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"));
+  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"));
+  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"));
+  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;
-});
+  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")));
-});
+  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")));
-});
+  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");
-}));
+
+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")
+  }),
+)