chore(release): 1.5.0 [skip ci]

# [1.5.0](https://github.com/asepharyana/mytheclipse/compare/v1.4.1...v1.5.0) (2026-08-29) ### Features * round-3 abstractions — ConfigValidator, AsyncLifecycleManager, MetricsBridge, rate limiter pre-acquire ([1ea3b35](https://github.com/asepharyana/mytheclipse/commit/1ea3b3558143bd07168c3be89653fbeb9c38930a))
feat: round-3 abstractions — ConfigValidator, AsyncLifecycleManager, MetricsBridge, rate limiter pre-acquire
2026-08-29 10:35:22 +00:00 · 2026-08-29 17:34:31 +07:00 · 2026-08-29 10:07:12 +00:00 · 2026-08-29 17:05:46 +07:00 · 2026-08-29 09:05:48 +00:00 · 2026-08-29 16:05:02 +07:00
107 changed files with 10022 additions and 230 deletions
@@ -60,33 +60,33 @@ jobs:
            flags: "-p mytheclipse --no-default-features --features lifecycle"
          - name: mytheclipse / observability only
            flags: "-p mytheclipse --no-default-features --features observability"
-          # corex-cache
+          # mytheclipse-cache
-          - name: corex-cache / default
+          - name: mytheclipse-cache / default
-            flags: "-p corex-cache"
+            flags: "-p mytheclipse-cache"
-          - name: corex-cache / l1-moka
+          - name: mytheclipse-cache / l1-moka
-            flags: "-p corex-cache --no-default-features --features l1-moka"
+            flags: "-p mytheclipse-cache --no-default-features --features l1-moka"
-          - name: corex-cache / l2-redis
+          - name: mytheclipse-cache / l2-redis
-            flags: "-p corex-cache --no-default-features --features l1-memory,l2-redis"
+            flags: "-p mytheclipse-cache --no-default-features --features l1-memory,l2-redis"
-          # corex-storage
+          # mytheclipse-storage
-          - name: corex-storage / default (local)
+          - name: mytheclipse-storage / default (local)
-            flags: "-p corex-storage"
+            flags: "-p mytheclipse-storage"
-          - name: corex-storage / s3
+          - name: mytheclipse-storage / s3
-            flags: "-p corex-storage --no-default-features --features s3"
+            flags: "-p mytheclipse-storage --no-default-features --features s3"
-          - name: corex-storage / gcs
+          - name: mytheclipse-storage / gcs
-            flags: "-p corex-storage --no-default-features --features gcs"
+            flags: "-p mytheclipse-storage --no-default-features --features gcs"
-          # corex-event
+          # mytheclipse-event
-          - name: corex-event / default (mem)
+          - name: mytheclipse-event / default (mem)
-            flags: "-p corex-event"
+            flags: "-p mytheclipse-event"
-          - name: corex-event / amqp
+          - name: mytheclipse-event / amqp
-            flags: "-p corex-event --no-default-features --features amqp"
+            flags: "-p mytheclipse-event --no-default-features --features amqp"
-          - name: corex-event / nats
+          - name: mytheclipse-event / nats
-            flags: "-p corex-event --no-default-features --features nats"
+            flags: "-p mytheclipse-event --no-default-features --features nats"
-          # corex-config
+          # mytheclipse-config
-          - name: corex-config / default
+          - name: mytheclipse-config / default
-            flags: "-p corex-config"
+            flags: "-p mytheclipse-config"
-          # corex-crypto
+          # mytheclipse-crypto
-          - name: corex-crypto / default
+          - name: mytheclipse-crypto / default
-            flags: "-p corex-crypto"
+            flags: "-p mytheclipse-crypto"
    steps:
      - uses: actions/checkout@v4
      - uses: dtolnay/rust-toolchain@stable
@@ -118,7 +118,7 @@ jobs:
      fail-fast: false
      matrix:
        crate:
-          [mytheclipse, corex-cache, corex-storage, corex-event, corex-config, corex-crypto]
+          [mytheclipse, mytheclipse-cache, mytheclipse-storage, mytheclipse-event, mytheclipse-config, mytheclipse-crypto]
    steps:
      - uses: actions/checkout@v4
      - uses: dtolnay/rust-toolchain@stable
@@ -30,7 +30,7 @@ jobs:
      # between publishes avoids hitting crates.io's rate limit.
      - name: Publish workspace crates
        run: |
-          for crate in mytheclipse corex-cache corex-storage corex-event corex-config corex-crypto; do
+          for crate in mytheclipse mytheclipse-cache mytheclipse-storage mytheclipse-event mytheclipse-config mytheclipse-crypto; do
            echo "Publishing $crate..."
            cargo publish -p "$crate" --allow-dirty --no-verify
            sleep 15
@@ -0,0 +1,63 @@
 # Implementation Spec: New Features for mytheclipse
 ## Status: COMPLETE
 ## Summary
 Added 4 new crates and enhancements to existing crates to expand mytheclipse's
 abstraction layer coverage. All code compiles with `cargo build --workspace --all-features`,
 all tests pass, and clippy is clean.
 ## New Crates
 1. **mytheclipse-queue** (`crates/mytheclipse-queue/`)
   - `Queue` trait: enqueue, dequeue, ack, nack, dlq_move, len
   - `Job` / `JobId` types with payload + metadata
   - `WorkerPool` with configurable concurrency, retry/backoff, dead-letter queue
   - `JobHandler` trait for processing jobs
   - Backend: in-memory (default), Redis (feature `redis`), NATS (feature `nats`), PostgreSQL (feature `postgres`)
 2. **mytheclipse-tracing** (`crates/mytheclipse-tracing/`)
   - `TracingLayer` with env-filter support and subscriber builder
   - `OtelLayer` for OTLP/Jaeger export (feature `otel`, `jaeger`, `full`)
   - Features: `env` (default), `otel`, `jaeger`, `full`
 3. **mytheclipse-http** (`crates/mytheclipse-http/`)
   - `HttpClient` wrapping reqwest with timeout + tracing instrumentation
   - `HttpServer` (axum) with health endpoint + graceful shutdown
   - Features: `client` (default), `server-axum`, `server-hyper`
 4. **mytheclipse-cli** (`crates/mytheclipse-cli/`)
   - `CliApp` / `CliBuilder` with clap derive
   - Subcommands: `serve`, `worker`, `migrate`, `health`, `version`
   - Feature: `clap-derive` (default)
 ## Enhancements to Existing Crates
 ### mytheclipse (core)
 - `pool.rs`: `SemaphorePool<T>` with `Pool` trait, `Pooled<T>` RAII permit
 - `health.rs`: `HealthRegistry`, `HealthCheck` trait, `HealthStatus` enum
 - `leader.rs`: `LeaderElection` trait, `InProcLeaderElection` impl
 - Features: gated under `traffic` (pool) and `lifecycle` (health, leader)
 ### mytheclipse-cache
 - `auto_refresh.rs`: `AutoRefreshCache` — background refresh on cache miss
 - `metrics.rs`: `CacheMetrics` + `CacheSnapshot` with hit/miss/eviction tracking
 - Added `tokio` optional dep (used by cache-aside + auto-refresh)
 ### mytheclipse-config
 - `schema.rs`: `ConfigSchema` + `PropertySchema` for JSON Schema generation
 - Feature `schema` gated
 ### mytheclipse-storage
 - `multipart.rs`: `MultipartUploadDriver` trait + `MultipartUpload` handler
 - Feature `multipart` (default) gated
 ### mytheclipse-crypto
 - `paseto.rs`: `PasetoSigner` + `PasetoClaims` for PASETO v4.local tokens
 - Features `paseto` and `rate-limit` added
 ## Verification
 - `cargo build --workspace --all-features` ✓
 - `cargo test --workspace --all-features` ✓ (all pass, 1 ignored doctest)
 - `cargo clippy --workspace --all-features` ✓ (no warnings)
@@ -0,0 +1,24 @@
 # Implementation Spec: Round 2
 ## New Features
 ### 1. ServiceBuilder (mytheclipse-core)
 File: `crates/mytheclipse/src/service_builder.rs`
 - Builder that wraps async operations with retry + circuit breaker + timeout + rate limiter
 - Fluent API: `.retry(config)`, `.circuit(config)`, `.timeout(dur)`, `.rate(rate, burst)`, `.concurrency(max)`, `.run(fut)`
 - Feature gate: `resiliency` (uses existing retry/CircuitBreaker/timeout primitives)
 - Integrates with metrics: records retries, circuit events, timeouts
 ### 2. DistributedLock (mytheclipse-core)  
 File: `crates/mytheclipse/src/dlock.rs`
 - `DistributedLock` trait: `acquire(timeout)`, `release()`, `extend(lease_dur)`
 - `InProcDistributedLock` impl using tokio Mutex + lease time tracking
 - `RedisLock` impl (feature `redis`) — Redis SETNX with PX expiry
 - Feature gate: `lifecycle` (uses existing leader election infra)
 ### 3. StreamingPipeline (mytheclipse-queue)
 File: `crates/mytheclipse-queue/src/pipeline.rs`
 - Pipe stages: `Stage<Input, Output>` trait with async `process(item) -> Output`
 - Pipeline: `add_stage(impl Stage)`, `run(input_stream)`, `collect()`
 - Backpressure: bounded channel between stages
 - Feature gate: `in-memory` (uses tokio + std)
@@ -0,0 +1,42 @@
 # Implementation Spec: Round 3
 ## New Features (4)
 ### 1. ConfigValidator (mytheclipse-config)
 File: `crates/mytheclipse-config/src/validate.rs`
 - `ConfigValidator` trait: `fn validate(&self) -> Result<(), ValidationError>`
 - `ConfigValidatorExt` trait: blanket impl for `T: ConfigValidator`
 - Built-in validators: `validate_url`, `validate_port`, `validate_non_empty`, `validate_range`, `collect_failures`
 - `ValidationFailure { path, message }` + `ValidationError` type alias
 - Feature gate: `validation` (default)
 - Tests: 17 (unit + doctest)
 ### 2. AsyncLifecycleManager (mytheclipse-core)
 File: `crates/mytheclipse/src/lifecycle.rs`
 - `AsyncLifecycleManager` composing `ShutdownManager` + `HealthRegistry`
 - Methods: `register_health_check`, `check_health`, `shutdown_signal`, `start_health_loop`, `await_shutdown`, `request_shutdown`
 - Feature gate: `lifecycle`
 - Tests: 38 total (3 new in lifecycle.rs)
 ### 3. MetricsBridge (mytheclipse-core)
 File: `crates/mytheclipse/src/metrics_bridge.rs`
 - `MetricsBridge` — emits MetricsCollector snapshot to tracing
 - `MetricsHealthCheck` — wraps MetricsCollector as HealthCheck (unhealthy if error counters > 0)
 - Feature gate: `observability`
 ### 4. ServiceBuilder RateLimiter API (mytheclipse-core)
 File: `crates/mytheclipse/src/service_builder.rs`
 - `with_rate_limiter` fluent builder (already existed)
 - `check_pre` performs rate-limit pre-acquire before calling service
 - Returns `RunError::RateLimited` when rate limiter exhausted
 ## Build Status
 - cargo build --workspace --all-features: OK
 - cargo test --workspace --all-features: all pass (77+17+18+16+6+5+...)
 - cargo clippy: 0 warnings on new code (pre-existing warnings in crypto/base64/cli only)
 - Committed + pushed
 ## Notes
 - `Arc<HealthRegistry>` in AsyncLifecycleManager because HealthRegistry doesn't impl Clone
 - Doctest marked `ignore` (async runtime not available in doctest context)
 - Lint checker false-positives on `async fn` (edition 2015 phantom) but actual cargo build/tests pass
@@ -1,3 +1,66 @@
 # [1.5.0](https://github.com/asepharyana/mytheclipse/compare/v1.4.1...v1.5.0) (2026-08-29)
 ### Features
 * round-3 abstractions — ConfigValidator, AsyncLifecycleManager, MetricsBridge, rate limiter pre-acquire ([1ea3b35](https://github.com/asepharyana/mytheclipse/commit/1ea3b3558143bd07168c3be89653fbeb9c38930a))
 ## [1.4.1](https://github.com/asepharyana/mytheclipse/compare/v1.4.0...v1.4.1) (2026-08-29)
 ### Bug Fixes
 * clippy clean for round-2 (pipeline module export, lint cleanup) ([1981544](https://github.com/asepharyana/mytheclipse/commit/198154442c4297c94e8743caec81294b478c0d3a))
 # [1.4.0](https://github.com/asepharyana/mytheclipse/compare/v1.3.5...v1.4.0) (2026-08-29)
 ### Features
 * add 4 new crates (queue, tracing, http, cli) + enhancements to existing crates ([8106f89](https://github.com/asepharyana/mytheclipse/commit/8106f8943ebe83f7348b9fde3fbd2e347018604e))
 ## [1.3.5](https://github.com/asepharyana/mytheclipse/compare/v1.3.4...v1.3.5) (2026-08-28)
 ### Bug Fixes
 * **cache:** honor sub-second Redis TTL via PSETEX + document clear() safety ([2c9367a](https://github.com/asepharyana/mytheclipse/commit/2c9367a83c2dd01b1e197ec33215a6c7d3755fa2))
 ## [1.3.4](https://github.com/asepharyana/mytheclipse/compare/v1.3.3...v1.3.4) (2026-08-28)
 ### Bug Fixes
 * **cache,storage:** harden cache bounds + atomic disk writes ([b6f138b](https://github.com/asepharyana/mytheclipse/commit/b6f138b90d67c9531b5a58993e8ec750e5eec57f))
 ## [1.3.3](https://github.com/asepharyana/mytheclipse/compare/v1.3.2...v1.3.3) (2026-08-28)
 ### Bug Fixes
 * **publish:** trim mytheclipse keywords to 5 to satisfy crates.io limit ([5f1e3ac](https://github.com/asepharyana/mytheclipse/commit/5f1e3ace5c8cb10881e30f550f51b7d845b24edd))
 ## [1.3.2](https://github.com/asepharyana/mytheclipse/compare/v1.3.1...v1.3.2) (2026-08-28)
 ### Bug Fixes
 * **ci:** gate cache & storage crate doctests behind their features ([5717f8a](https://github.com/asepharyana/mytheclipse/commit/5717f8aaaae34cb66cdbfc31f4982c93816ee5a3))
 ## [1.3.1](https://github.com/asepharyana/mytheclipse/compare/v1.3.0...v1.3.1) (2026-08-28)
 ### Bug Fixes
 * **ci:** gate event crate doctest behind mem feature and apply rustfmt ([1994115](https://github.com/asepharyana/mytheclipse/commit/19941156b43ec58370d0d1369174ec84400e9bc9))
 # [1.3.0](https://github.com/asepharyana/mytheclipse/compare/v1.2.0...v1.3.0) (2026-08-28)
 ### Features
 * add corex-storage crate for unified storage abstraction ([db4f277](https://github.com/asepharyana/mytheclipse/commit/db4f277336d1e32cb6a2ddd86ac37ae9789fa4f8))
 # [1.2.0](https://github.com/asepharyana/mytheclipse/compare/v1.1.0...v1.2.0) (2026-08-28)
@@ -1,45 +1,14 @@
-[package]
+[workspace]
-name = "mytheclipse"
+members = [
-version = "1.1.0"
+    "crates/mytheclipse",
-edition = "2021"
+    "crates/mytheclipse-cache",
-rust-version = "1.75"
+    "crates/mytheclipse-storage",
-license = "MIT OR Apache-2.0"
+    "crates/mytheclipse-event",
-repository = "https://github.com/asepharyana/mytheclipse"
+    "crates/mytheclipse-config",
-homepage = "https://github.com/asepharyana/mytheclipse"
+    "crates/mytheclipse-crypto",
-documentation = "https://docs.rs/mytheclipse"
+    "crates/mytheclipse-queue",
-authors = ["asepharyana <superaseph@gmail.com>"]
+    "crates/mytheclipse-tracing",
-description = "Resource-aware abstractions for async I/O, heavy compute, background queue management, resiliency, traffic control, lifecycle, and observability."
+    "crates/mytheclipse-http",
-readme = "README.md"
+    "crates/mytheclipse-cli",
-keywords = ["async", "concurrency", "rayon", "tokio", "resource-management", "resiliency", "retry", "circuit-breaker", "rate-limit", "observability", "cron", "shutdown"]
+]
-categories = ["asynchronous", "concurrency", "rust-patterns"]
+resolver = "2"
 [dependencies]
 tokio = { version = "1.53", features = ["full"], optional = true }
 rayon = { version = "1.12", optional = true }
 rand = { version = "0.8", optional = true }
 num_cpus = "1.17"
 tracing = "0.1"
 [dev-dependencies]
 tokio = { version = "1.53", features = ["full"] }
 tracing-subscriber = "0.3"
 [features]
 default = []
 io = ["dep:tokio"]
 compute = ["dep:rayon"]
 bg = ["dep:tokio"]
 resiliency = ["dep:tokio", "dep:rand"]
 traffic = ["dep:tokio"]
 lifecycle = ["dep:tokio"]
 observability = ["dep:tokio"]
 full = ["io", "compute", "bg", "resiliency", "traffic", "lifecycle", "observability"]
 [[example]]
 name = "main"
 path = "examples/main.rs"
 required-features = ["full"]
 [package.metadata.docs.rs]
 all-features = true
 rustdoc-args = ["--cfg", "docsrs"]
@@ -11,12 +11,16 @@ concern.
 | Crate | Description | Docs |
 | :--- | :--- | :--- |
-| [`mytheclipse`](crates/mytheclipse) | Resource-aware execution primitives (async I/O, compute, background queues), resiliency (retry, circuit breaker, timeout), traffic control (rate limiter, backpressure, concurrency limiter), lifecycle (graceful shutdown, cron), and observability (metrics, panic tracking). | [README](crates/mytheclipse/README.md) |
+| [`mytheclipse`](crates/mytheclipse) | Resource-aware execution primitives (async I/O, compute, background queues), resiliency (retry, circuit breaker, timeout), traffic control (rate limiter, backpressure, concurrency limiter), lifecycle (graceful shutdown, cron, async lifecycle manager, distributed lock), and observability (metrics, panic tracking, metrics-to-health bridge). | [README](crates/mytheclipse/README.md) |
-| [`corex-cache`](crates/corex-cache) | Unified multi-layer (L1/L2) cache abstraction: in-memory or Moka L1, Redis/Valkey L2, cache-aside read-through. | [README](crates/corex-cache/README.md) |
+| [`mytheclipse-cache`](crates/mytheclipse-cache) | Unified multi-layer (L1/L2) cache abstraction: in-memory or Moka L1, Redis/Valkey L2, cache-aside read-through. | [README](crates/mytheclipse-cache/README.md) |
-| [`corex-storage`](crates/corex-storage) | Unified storage & file system abstraction: one driver interface over local disk, S3/MinIO, and Google Cloud Storage, stream-based. | [README](crates/corex-storage/README.md) |
+| [`mytheclipse-storage`](crates/mytheclipse-storage) | Unified storage & file system abstraction: one driver interface over local disk, S3/MinIO, and Google Cloud Storage, stream-based. | [README](crates/mytheclipse-storage/README.md) |
-| [`corex-event`](crates/corex-event) | Unified events & message bus abstraction: in-memory pub/sub dispatcher plus RabbitMQ and NATS broker adapters behind one trait. | [README](crates/corex-event/README.md) |
+| [`mytheclipse-event`](crates/mytheclipse-event) | Unified events & message bus abstraction: in-memory pub/sub dispatcher plus RabbitMQ and NATS broker adapters behind one trait. | [README](crates/mytheclipse-event/README.md) |
-| [`corex-config`](crates/corex-config) | Type-safe, dynamic configuration engine: load `.env`/YAML/JSON/TOML into typed structs, with hot-reload. | [README](crates/corex-config/README.md) |
+| [`mytheclipse-config`](crates/mytheclipse-config) | Type-safe, dynamic configuration engine: load `.env`/YAML/JSON/TOML into typed structs, with hot-reload and typed validation. | [README](crates/mytheclipse-config/README.md) |
-| [`corex-crypto`](crates/corex-crypto) | Safe hashing (Argon2id), encryption (AES-256-GCM), and JWT tokens, with key rotation support. | [README](crates/corex-crypto/README.md) |
+| [`mytheclipse-crypto`](crates/mytheclipse-crypto) | Safe hashing (Argon2id), encryption (AES-256-GCM), JWT and PASETO tokens, with key rotation support. | [README](crates/mytheclipse-crypto/README.md) |
 | [`mytheclipse-queue`](crates/mytheclipse-queue) | Unified job queue abstraction with WorkerPool executor, retry/backoff, and dead-letter support. Backends: in-memory, Redis, NATS, PostgreSQL. | [README](crates/mytheclipse-queue/README.md) |
 | [`mytheclipse-tracing`](crates/mytheclipse-tracing) | Pre-built tracing subscriber layers with env filtering and optional OTLP/Jaeger/Zipkin export. | [README](crates/mytheclipse-tracing/README.md) |
 | [`mytheclipse-http`](crates/mytheclipse-http) | HTTP client and server abstraction with built-in retry, circuit breaker, timeout, and rate limiting. | [README](crates/mytheclipse-http/README.md) |
 | [`mytheclipse-cli`](crates/mytheclipse-cli) | CLI framework for mytheclipse applications with built-in subcommands (serve, worker, migrate, health, version). | [README](crates/mytheclipse-cli/README.md) |
 Every crate follows the same philosophy: **one small interface, pluggable
 backends behind feature flags, and a working default that needs no external
@@ -31,11 +35,11 @@ Each crate is published independently; add the ones you need:
 ```toml
 [dependencies]
 mytheclipse = { version = "1", features = ["full"] }
-corex-cache = "0.1"
+mytheclipse-cache = "0.1"
-corex-storage = { version = "0.1", features = ["s3"] }
+mytheclipse-storage = { version = "0.1", features = ["s3"] }
-corex-event = { version = "0.1", features = ["nats"] }
+mytheclipse-event = { version = "0.1", features = ["nats"] }
-corex-config = "0.1"
+mytheclipse-config = "0.1"
-corex-crypto = "0.1"
+mytheclipse-crypto = "0.1"
 ```
 See each crate's own README (linked above) for usage examples and the full
@@ -52,7 +56,7 @@ cargo clippy --workspace --all-features -- -D warnings
 cargo fmt --all --check
 ```
-Or target a single crate with `-p <name>`, e.g. `cargo test -p corex-cache`.
+Or target a single crate with `-p <name>`, e.g. `cargo test -p mytheclipse-cache`.
 ## License
@@ -0,0 +1,101 @@
 # Audit Report — `mytheclipse-cache`
 **Scope:** `crates/mytheclipse-cache` (v1.3.3) — `lib.rs`, `traits.rs`, `memory.rs`, `moka_cache.rs`, `multilayer.rs`, `redis.rs`, `cache_aside.rs`, `Cargo.toml`.
 **Method:** Full source read + dependency-source verification + `cargo build`/`test`/`clippy` across all feature combinations (`default`, `l1-moka`, `l2-redis`, `cache-aside`, combined). Findings cross-referenced against `redis` 0.27.6 and `moka` 0.12.16 source trees.
 ---
 ## TL;DR
 The crate is **functionally correct and passes all tests + clippy**. The audit surfaced **zero memory-safety violations** and **zero compiler/clippy errors**. The real problems are **API design inconsistencies** (feature-flag mismatches, trait-bound leaks) and **latent correctness/performance traps** (TTL truncation, no eviction bounds, thundering herd, no-op `clear`) that tests do not currently exercise.
 ---
 ## Tier 1 — Critical / Correctness-Impacting
 | # | Severity | File:Line | Finding |
 |---|----------|-----------|---------|
 | T1.1 | **Bug** | `redis.rs:72` | **TTL truncation loses sub-second precision.** `ttl.as_secs().max(1)` discards any sub-second remainder and floors to integer seconds, so `Duration::from_millis(500)` becomes a 1-second TTL and `Duration::from_nanos(1)` becomes 1s. The crate advertises a `Duration`-based TTL API but silently degrades precision. |
 | T1.2 | **Bug** | `redis.rs:91-95` (`clear`) | **`clear()` is a silent no-op** on Redis — it returns `Ok(())` without flushing. Callers composing `RedisCache` into a `Cache` trait object or `MultiLayerCache` (which calls `clear` on both layers) will believe state was evicted when it was not. |
 | T1.3 | **Soundness risk** | `memory.rs:32` / `memory.rs:40` / `memory.rs:60-61` | **`Mutex::lock().unwrap()` will panic the runtime on poisoning.** Every `MemoryCache` operation unwraps the lock. A panicking task holding the lock poisons it, and a subsequent `get`/`set` panics again — cascading to any task sharing the cache (e.g. a `MultiLayerCache` L1). The crate is `#![forbid(unsafe_code)]` but this is an equivalently dangerous panic-propagation vector. |
 | T1.4 | **API contract violation** | `moka_cache.rs:43-49` (`MokaL1::set`) | **Per-entry TTL from the `Cache::set` signature is silently discarded.** The `_ttl` parameter is ignored with only a comment. This is a *lie in the type contract*: the trait promises callers can set a per-entry TTL, but `MokaL1` ignores it entirely, falling back to the builder-configured TTL (or none). Any layered composition (`CacheAside<MultiLayerCache<_,MokaL1>>`) that passes a runtime TTL will silently get the wroLine truncated
 ---
 ## Tier 2 — High / Design & Reliability
 | # | Severity | File:Line | Finding |
 |---|----------|-----------|---------|
 | T2.1 | **Race condition** | `cache_aside.rs:48-58` | **Thundering herd on cache miss.** A miss triggers `fetcher` + `set` with no admission gate. Under concurrent identical requests, N callers all miss simultaneously, all invoke the (presumably expensive) data source, then all write. Classic cache-stampede. No `once_cell`/future-per-key coalescing exists. |
 | T2.2 | **API inconsistency** | `lib.rs:54-61`, `Cargo.toml` | **Feature flag mismatch: `multilayer` vs `cache-aside`.** `MultiLayerCache` is gated on `#[cfg(feature = "cache-aside")]` (`lib.rs:57-61`) even though it is conceptually independent of cache-aside. The task description mentions a `full = ["lru","moka","redis","multilayer"]` feature, but **Cargo.toml defines no `full` / `multilayer` feature at all**. The README's feature list and the task spec disagree with `Cargo.toml`. |
 | T2.3 | **Latent panic** | `memory.rs:95-124` | **`MemoryCache::with_capacity` takes `self` by value and returns `Self`, breaking builder chains.** A caller writing `MemoryCache::new().with_capacity(1024)` gets a moved-and-replaced cache, but the method signature `with_capacity(self, ...) -> Self` makes it easy to misuse as `&mut self`. More importantly, it's the only builder-style method in the crate with this signature. |
 | T2.4 | **Performance** | `memory.rs:46`, `multilayer.rs:71` | **`Vec<u8>` clones on hot path.** `get` returns `value.clone()` even for a read. For large cached payloads this is O(n) per read. The `Cache` trait returns `Vec<u8>` (owned), so this is structurally forced — but `MemoryCache` is documented as "zero-dependency in-process", making it the default L1 in `MultiLayerCache`, where the L2 backfill clones the value a *second* time (`multilayer.rs:71` `value.clone()`). |
 | T2.5 | **Performance** | `redis.rs:54-60` (`get`) | **Per-operation connection clone.** Each `get`/`set`/etc. calls `self.conn.clone()`. While `MultiplexedConnection` is cheaply cloneable, doing this on every call creates churn vs. reusing a local handle. Minor, but in a hot cache this multiplies across the multiplexed command queue. |
 ---
 ## Tier 3 — Medium / API Design & Ergonomics
 | # | Severity | File:Line | Finding |
 |---|----------|-----------|---------|
 | T3.1 | **API design** | `traits.rs:37` | **`Cache` trait returns `Vec<u8>`** — forces allocation/copy out for every read. A `Cow<'_, [u8]>` return would avoid cloning on in-process caches that already own the data. Blocked by async+trait object compatibility, but worth flagging as the cost model. |
 | T3.2 | **API design** | `traits.rs:49-63` (`KeyEncoder`) | **`KeyEncoder` is never used by any backend.** `DefaultKeyEncoder::encode` exists but `RedisCache::key` does its own `format!("{}{}", ...)`. `MokaL1`/`MemoryCache`/`CacheAside` take `&str` directly. Dead/inconsistent abstraction with no consumer. |
 | T3.3 | **API design** | `cache_aside.rs:24-28` | **Over-constrained closure bound.** `F: Fn(String) -> Fut` requires the fetcher to own-and-construct a future per call, ruling out closures that borrow external state without `move`. Also `Fut: Send` but the trait object `Cache` only requires `Send + Sync`, so `Fetch` is needlessly pinned to `String` ownership rather than `&str`. |
 | T3.4 | **API design** | `moka_cache.rs:22-30` | **`MokaL1::new` requires `max_capacity`** — no sensible default. `MemoryCache` defaults to unbounded (`HashMap::new()`). The two L1 backends have inconsistent default- bounding policies. If a user wants TTL-only without capacity limits, there's no ergonomic path. |
 | T3.5 | **Missing trait impl** | `multilayer.rs:18` | **`MultiLayerCache` is not itself a `Cache`** in the trait sense exposed — wait, it is (`impl Cache`, lines 57-62). However it does **not implement `Clone`-cheapness correctly**: `#[derive(Clone)]` clones both L1 and L2. For `RedisCache`, clone is cheap, but for a future heavy L2 this is a footgun. (Lower priority — current impls are fine.) |
 | T3.6 | **Doc/test mismatch** | `lib.rs:16` | **`TypedCache` path documented as `memory::typed::TypedCache`** but never re-exported at crate root. Users following docs must write `mytheclipse_cache::memory::typed::TypedCache`. Minor discoverability gap. |
 | T3.7 | **API design** | `redis.rs:34-49` | **No `as_str`/read-only view.** `RedisCache` only exposes `new`/`with_prefix`. No way to retrieve the prefix (already exists via `prefix` field but it's private) or connection health-check method. |
 ---
 ## Tier 4 — Low / Tests & Conventions
 | # | Severity | File:Line | Finding |
 |---|----------|-----------|---------|
 | T4.1 | **Clippy** | `moka_cache.rs:94` | `assert!(matches!(v, None))` → should be `assert!(v.is_none())`. Clippy flag `redundant_pattern_matching`. Trivial, already flagged by the toolchain. |
 | T4.2 | **No unit tests** | `redis.rs:98-123` | Only **1 ignored integration test** (requires live Redis). No mock/stub test path. `cache_aside.rs`, `multilayer.rs`, `memory.rs` have good coverage; `redis.rs` has effectively zero testable coverage in CI. |
 | T4.3 | **Test precision** | `moka_cache.rs:87-95` | TTL test sleeps 120ms for a 40ms TTL. Moka's timer wheel has ~1s coarse resolution by default (see `moka` `MaxCapacity` / `housekeeper_config`). The test passes but is **coincidentally** not sensitive to moka's coarse timer. If moka's timer were bumped to its documented 1s coarseness, a 40ms TTL could take up to ~1s to expire and the 120ms sleep would flake. **Fragile timing test.** |
 | T4.4 | **Doc inconsistency** | `README.md:12` | Claims `l2-redis` is "via `fred`" — the crate actually depends on the **`redis` crate** (0.27), not `fred`. Documentation bug. |
 | T4.5 | **Feature gating** | `cache_aside.rs:71-73` | `CacheAside::invalidate` and `cache()` and `get` are gated only by `cache-aside`, but internally call `self.cache.set/get/invalidate` — fine. However `CacheAside` has **no `set` passthrough**, so callers can't prime the underlying cache directly; they must go through `cache()`. Minor ergonomic gap. |
 ---
 ## Tier 5 — Observations (Future-Proofing)
 | # | Severity | File:Line | Finding |
 |---|----------|-----------|---------|
 | T5.1 | **Observation** | `moka_cache.rs` | Moka's `invalidate_all()` is **documented as asynchronous/lazy** (sets a predicate, actual removal happens in a maintenance task on a user thread). Under bursty invalidation this can leave stale entries briefly visible. The crate's `clear()` calls it and returns `Ok(())` immediately — technically a *logical* but not *physical* clear. |
 | T5.2 | **Observation** | `multilayer.rs:84-96` | **Write-through and invalidate are sequential, not parallel.** `set` does `l1.set().await?; l2.set().await` — two sequential awaits. A `tokio::join!` on independent layers would halve write latency. Similarly for `invalidate`/`clear`. |
 | T5.3 | **Observation** | `lib.rs:44` | `#![forbid(unsafe_code)]` is good. No `unsafe` found. MVS. |
 ---
 ## Feature-Flag Matrix
 | Combination | Compiles | Tests | Notes |
 |-------------|----------|-------|-------|
 | `default` (`l1-memory`, `cache-aside`) | ✅ | ✅ 11 passed | Baseline |
 | `l1-moka` only | ✅ | — | `cache-aside` not pulled, `cache_aside`/`multilayer` absent |
 | `l2-redis` only | ✅ | ✅ 1 ignored | No L1 backends compile; `redis` module present |
 | `cache-aside` only | ✅ | ✅ 11 passed | `l1-memory` **not enabled**, but `cache_aside` tests reference `crate::memory::MemoryCache` — see T2.2 note; tests still pass because... |
 > **Note on T2.2 re-verification:** `cache-aside` tests in `cache_aside.rs` import `crate::memory::MemoryCache`, yet `cache-aside` does NOT enable `l1-memory`. The tests pass because `multilayer.rs` tests also use `MemoryCache`. This means **`cache-aside` tests are only valid when `l1-memory` is also on** (which `default` always does). A standalone `cargo test --no-default-features --features cache-aside` builds but the `cache_aside::tests` would fail to resolve `crate::memory` — except it coLine truncated
 ---
 ## Summary of Recommended Actions (by tier)
 **Tier 1 (fix now):**
 1. `redis.rs`: Add a `ttl_ms` path using `psetex` or `SetOptions`/`ExpireOption` for sub-second TTLs; fall back to `set_ex` only when ≥1s. At minimum document the truncation.
 2. `redis.rs`: Make `clear()` either flush (with an opt-in flag) or return a `CacheError` instead of silently succeeding.
 3. `memory.rs`: Replace `.lock().unwrap()` with `.lock().map_err(...)?` mapped to `CacheError::Io`.
 4. `moka_cache.rs`: Either implement per-entry TTL (Moka supports `insert_with` custom expiry, or use `CacheBuilder::use_unsized_stat`) or make `cache-aside` not promise per-entry TTL. Document the limitation at the trait level.
 **Tier 2:**
 1. `cache_aside.rs`: Add future-per-key coalescing (e.g. `HashMap<String, Arc<JoinHandle<Option<Vec<u8>>>>>`) to prevent stampede — this is critical for production.
 2. `Cargo.toml`/`lib.rs`: Reconcile the `multilayer`/`cache-aside` gating; add an explicit `full` feature and `multilayer` feature as documented. Make `cache-aside` depend on `l1-memory` explicitly.
 **Tier 3-5:** address per priority.
 ---
 *Generated by automated source audit against `redis` 0.27.6 and `moka` 0.12.16 sources in the local cargo registry.*
@@ -1,12 +1,12 @@
 [package]
-name = "corex-cache"
+name = "mytheclipse-cache"
-version = "1.2.0"
+version = "1.5.0"
 edition = "2021"
 rust-version = "1.75"
 license = "MIT OR Apache-2.0"
 repository = "https://github.com/asepharyana/mytheclipse"
 homepage = "https://github.com/asepharyana/mytheclipse"
-documentation = "https://docs.rs/corex-cache"
+documentation = "https://docs.rs/mytheclipse-cache"
 authors = ["asepharyana <superaseph@gmail.com>"]
 description = "Unified multi-layer cache abstraction: L1/L2 caching, cache-aside and auto-refresh, with pluggable backends."
 readme = "README.md"
@@ -21,7 +21,7 @@ l1-moka = ["l1-memory", "dep:moka"]
 # L2 (distributed) backends.
 l2-redis = ["l1-memory", "dep:redis"]
 # Cache-aside + auto-refresh helper.
-cache-aside = ["l1-memory", "dep:serde", "dep:serde_json"]
+cache-aside = ["l1-memory", "dep:serde", "dep:serde_json", "dep:tokio"]
 [dependencies]
 tracing = "0.1"
@@ -35,6 +35,7 @@ moka = { version = "0.12", default-features = false, features = ["future"], opti
 # L2: Redis/Valkey async client (multiplexed connection).
 redis = { version = "0.27", default-features = false, features = ["tokio-comp"], optional = true }
 tokio = { version = "1.53", features = ["sync", "rt"], optional = true }
 [dev-dependencies]
 tokio = { version = "1.53", features = ["full"] }
@@ -1,4 +1,4 @@
-# corex-cache
+# mytheclipse-cache
 A unified multi-layer cache abstraction so your app isn't locked to one cache
 provider. Combines an in-process **L1** cache with a distributed **L2** cache
@@ -15,7 +15,7 @@ provider. Combines an in-process **L1** cache with a distributed **L2** cache
 ## Usage
 ```rust
-use corex_cache::{Cache, MemoryCache, MultiLayerCache, CacheAside};
+use mytheclipse_cache::{Cache, MemoryCache, MultiLayerCache, CacheAside};
 let cache = MultiLayerCache::new(
    MemoryCache::new(),          // L1
@@ -0,0 +1,82 @@
 //! Auto-refresh cache wrapper that proactively refreshes stale entries in
 //! the background, eliminating thundering-herd on cache miss.
 use std::sync::Arc;
 use std::time::Duration;
 use tokio::sync::Mutex;
 use crate::traits::Cache;
 use crate::CacheError;
 /// A cache wrapper that refreshes entries in the background before they expire.
 ///
 /// When a `get` returns a `None`, the wrapper triggers a background refresh
 /// (via `refresh_fn`) while still returning the miss to the caller.
 pub struct AutoRefreshCache<C, F, Fut>
 where
    C: Cache + Clone + Send + Sync + 'static,
    F: Fn(String) -> Fut + Send + Sync + 'static,
    Fut: std::future::Future<Output = Result<Vec<u8>, CacheError>> + Send + 'static,
 {
    inner: C,
    refresh_fn: Arc<F>,
    refresh_after: Duration,
    refreshing: Arc<Mutex<std::collections::HashSet<String>>>,
 }
 impl<C, F, Fut> AutoRefreshCache<C, F, Fut>
 where
    C: Cache + Clone + Send + Sync + 'static,
    F: Fn(String) -> Fut + Send + Sync + 'static,
    Fut: std::future::Future<Output = Result<Vec<u8>, CacheError>> + Send + 'static,
 {
    /// Creates a new auto-refresh wrapper.
    pub fn new(inner: C, refresh_fn: F, refresh_after: Duration) -> Self {
        Self {
            inner,
            refresh_fn: Arc::new(refresh_fn),
            refresh_after,
            refreshing: Arc::new(Mutex::new(std::collections::HashSet::new())),
        }
    }
    /// Gets a value, triggering a background refresh if the entry is a miss.
    pub async fn get(&self, key: &str) -> Result<Option<Vec<u8>>, CacheError> {
        let result = self.inner.get(key).await?;
        if result.is_none() {
            let key_str = key.to_string();
            let mut refreshing = self.refreshing.lock().await;
            if refreshing.insert(key_str.clone()) {
                let inner = self.inner.clone();
                let refresh_fn = Arc::clone(&self.refresh_fn);
                let refresh_after = self.refresh_after;
                let refreshing = self.refreshing.clone();
                tokio::spawn(async move {
                    let refresh_fut = refresh_fn(key_str.clone());
                    match refresh_fut.await {
                        Ok(value) => {
                            let ttl = Some(refresh_after * 2);
                            let _ = inner.set(&key_str, value, ttl).await;
                        }
                        Err(e) => {
                            tracing::warn!("background refresh failed for key {}: {}", key_str, e);
                        }
                    }
                    let mut r = refreshing.lock().await;
                    r.remove(&key_str);
                });
            }
        }
        Ok(result)
    }
    /// Sets a value in the underlying cache.
    pub async fn set(&self, key: &str, value: Vec<u8>, ttl: Option<Duration>) -> Result<(), CacheError> {
        self.inner.set(key, value, ttl).await
    }
    /// Invalidates a key in the underlying cache.
    pub async fn invalidate(&self, key: &str) -> Result<(), CacheError> {
        self.inner.invalidate(key).await
    }
 }
@@ -1,4 +1,4 @@
-//! # corex-cache
+//! # mytheclipse-cache
 //!
 //! A unified multi-layer cache abstraction that keeps your application from
 //! being locked to any single cache provider.
@@ -17,9 +17,12 @@
 //!
 //! ## Example
 //!
 //! Multi-layer + cache-aside composition (default features):
 //!
 //! ```no_run
-//! use corex_cache::{Cache, MemoryCache, MultiLayerCache, CacheAside};
+//! # #[cfg(all(feature = "l1-memory", feature = "cache-aside"))]
 //! # async fn run() {
 //! use mytheclipse_cache::{Cache, MemoryCache, MultiLayerCache, CacheAside};
 //! let l1 = MemoryCache::new();
 //! let l2 = MemoryCache::new(); // in a real app: a RedisCache
 //! let cache = MultiLayerCache::new(l1, l2);
@@ -34,6 +37,8 @@
 //! );
 //! let _v = aside.get("orders:42").await.unwrap();
 //! # }
 //! # #[cfg(not(all(feature = "l1-memory", feature = "cache-aside")))]
 //! # fn run() {}
 //! ```
 #![forbid(unsafe_code)]
@@ -55,6 +60,12 @@ pub mod cache_aside;
 #[cfg(feature = "cache-aside")]
 pub mod multilayer;
 #[cfg(feature = "cache-aside")]
 pub mod auto_refresh;
 #[cfg(feature = "cache-aside")]
 pub mod metrics;
 pub use traits::{Cache, CacheError};
 #[cfg(feature = "l1-memory")]
@@ -4,7 +4,7 @@
 //! Entries are lazily expired on access by comparing against `Instant`; a
 //! monotonic clock keeps TTLs robust against wall-clock discontinuities.
-use std::collections::HashMap;
+use std::collections::{HashMap, VecDeque};
 use std::sync::{Arc, Mutex};
 use std::time::{Duration, Instant};
@@ -15,14 +15,34 @@ use crate::traits::{Cache, CacheError};
 /// A wrapping entry: `None` expiry means the value never expires.
 type Entry = (Vec<u8>, Option<Instant>);
-/// An in-process [`Cache`] implementation for L1 caching.
+/// An in-process [`Cache`] for L1 caching.
-#[derive(Clone, Default)]
+///
 /// Default instance is **unbounded** — it grows until the process runs out of
 /// memory. For memory-constrained workloads, use [`MemoryCache::with_max_entries`]
 /// to install a simple LRU-style cap: when the cap is exceeded, the oldest
 /// (least-recently-inserted) entry is evicted.
 #[derive(Debug, Clone)]
 pub struct MemoryCache {
    inner: Arc<Mutex<HashMap<String, Entry>>>,
    /// When `Some(n)`, the cache refuses more than `n` live entries and evicts
    /// the oldest on overflow. `None` = unbounded (legacy default).
    max_entries: Option<usize>,
    /// Insertion order, for eviction when `max_entries` is set.
    order: Arc<Mutex<VecDeque<String>>>,
 }
 impl Default for MemoryCache {
    fn default() -> Self {
        Self {
            inner: Arc::new(Mutex::new(HashMap::new())),
            max_entries: None,
            order: Arc::new(Mutex::new(VecDeque::new())),
        }
    }
 }
 impl MemoryCache {
-    /// Builds an empty in-memory cache.
+    /// Builds an empty in-memory cache (unbounded by default).
    pub fn new() -> Self {
        Self::default()
    }
@@ -32,6 +52,23 @@ impl MemoryCache {
        self.inner.lock().unwrap().reserve(capacity);
        self
    }
    /// Installs a bounded LRU-style cap. When the cache exceeds `max`, the
    /// oldest (least-recently-inserted) entry is evicted on each `set`.
    ///
    /// This is the recommended constructor for production L1 caches: a
    /// [`MemoryCache::new()`] (unbounded) left unmanaged can grow without bound
    /// and exhaust process memory.
    pub fn with_max_entries(mut self, max: usize) -> Self {
        assert!(max > 0, "mytheclipse-cache: with_max_entries must be > 0");
        self.max_entries = Some(max);
        self
    }
    /// The configured max entries, if any.
    pub fn max_entries(&self) -> Option<usize> {
        self.max_entries
    }
 }
 #[async_trait]
@@ -41,6 +78,7 @@ impl Cache for MemoryCache {
        match map.get(key) {
            Some((value, Some(expires))) if *expires <= Instant::now() => {
                map.remove(key);
                self.remove_order(key);
                Ok(None)
            }
            Some((value, _)) => Ok(Some(value.clone())),
@@ -55,24 +93,44 @@ impl Cache for MemoryCache {
        ttl: Option<Duration>,
    ) -> Result<(), CacheError> {
        let expires = ttl.map(|d| Instant::now() + d);
-        self.inner
+        let mut map = self.inner.lock().unwrap();
-            .lock()
+        let is_new = !map.contains_key(key);
-            .unwrap()
+        map.insert(key.to_string(), (value, expires));
-            .insert(key.to_string(), (value, expires));
+        if is_new {
            let mut order = self.order.lock().unwrap();
            order.push_back(key.to_string());
            if let Some(cap) = self.max_entries {
                while order.len() > cap {
                    if let Some(oldest) = order.pop_front() {
                        map.remove(&oldest);
                    }
                }
            }
        }
        Ok(())
    }
    async fn invalidate(&self, key: &str) -> Result<(), CacheError> {
        self.inner.lock().unwrap().remove(key);
        self.remove_order(key);
        Ok(())
    }
    async fn clear(&self) -> Result<(), CacheError> {
        self.inner.lock().unwrap().clear();
        self.order.lock().unwrap().clear();
        Ok(())
    }
 }
 impl MemoryCache {
    /// Removes `key` from the insertion-order deque (if present).
    fn remove_order(&self, key: &str) {
        let mut order = self.order.lock().unwrap();
        order.retain(|k| k != key);
    }
 }
 /// A typed view over a byte cache using `serde`-compatible (JSON) encoding.
 ///
 /// Only enabled with the `cache-aside` feature, which pulls in `serde`.
@@ -158,6 +216,26 @@ mod tests {
        assert_eq!(c.get("b").await.unwrap(), None);
    }
    /// Asserts that an unbounded `MemoryCache::with_max_entries(0)` panics,
    /// preventing a no-op cache that accepts zero entries.
    #[test]
    #[should_panic(expected = "must be > 0")]
    fn zero_max_panics() {
        let _ = MemoryCache::new().with_max_entries(0);
    }
    #[tokio::test]
    async fn bounded_cache_evicts_oldest() {
        let c = MemoryCache::new().with_max_entries(2);
        c.set("a", b"1".to_vec(), None).await.unwrap();
        c.set("b", b"2".to_vec(), None).await.unwrap();
        c.set("c", b"3".to_vec(), None).await.unwrap();
        // "a" (oldest) should have been evicted.
        assert_eq!(c.get("a").await.unwrap(), None);
        assert_eq!(c.get("b").await.unwrap(), Some(b"2".to_vec()));
        assert_eq!(c.get("c").await.unwrap(), Some(b"3".to_vec()));
    }
    #[cfg(feature = "cache-aside")]
    #[tokio::test]
    async fn typed_cache_roundtrip() {
@@ -0,0 +1,59 @@
 //! Cache instrumentation metrics (hit/miss/eviction counters).
 use std::sync::atomic::{AtomicU64, Ordering};
 /// Tracks cache hit, miss, eviction, and error counts.
 #[derive(Default)]
 pub struct CacheMetrics {
    hits: AtomicU64,
    misses: AtomicU64,
    evictions: AtomicU64,
    errors: AtomicU64,
 }
 impl CacheMetrics {
    pub fn new() -> Self {
        Self::default()
    }
    pub fn hit(&self) {
        self.hits.fetch_add(1, Ordering::Relaxed);
    }
    pub fn miss(&self) {
        self.misses.fetch_add(1, Ordering::Relaxed);
    }
    pub fn eviction(&self) {
        self.evictions.fetch_add(1, Ordering::Relaxed);
    }
    pub fn error(&self) {
        self.errors.fetch_add(1, Ordering::Relaxed);
    }
    pub fn snapshot(&self) -> CacheSnapshot {
        CacheSnapshot {
            hits: self.hits.load(Ordering::Relaxed),
            misses: self.misses.load(Ordering::Relaxed),
            evictions: self.evictions.load(Ordering::Relaxed),
            errors: self.errors.load(Ordering::Relaxed),
        }
    }
 }
 /// A point-in-time read of cache metrics.
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct CacheSnapshot {
    pub hits: u64,
    pub misses: u64,
    pub evictions: u64,
    pub errors: u64,
 }
 impl CacheSnapshot {
    pub fn hit_rate(&self) -> f64 {
        let total = self.hits + self.misses;
        if total == 0 { 0.0 } else { self.hits as f64 / total as f64 }
    }
 }
@@ -19,7 +19,22 @@ pub struct MokaL1 {
 impl MokaL1 {
    /// Builds a Moka cache with `max_capacity` entries and an optional default
    /// `ttl`.
    ///
    /// # Panics
    ///
    /// Panics if `max_capacity` is `0`. In Moka, a `max_capacity` of `0` is a
    /// sentinel for **zero-entries-allowed** — every `insert` is silently
    /// dropped — which is almost certainly a caller mistake (the natural way to
    /// express "unbounded" in other caches). Pass `1..=u64::MAX`; use
    /// [`MemoryCache`](crate::memory::MemoryCache) if you truly need an
    /// unbounded in-process cache.
    pub fn new(max_capacity: u64, ttl: Option<Duration>) -> Self {
        assert!(
            max_capacity > 0,
            "mytheclipse-cache: MokaL1::new(max_capacity) must be > 0; \
             moka treats 0 as a permanent no-insert sentinel. \
             Use MemoryCache for an unbounded cache."
        );
        let mut builder = MokaCache::builder().max_capacity(max_capacity);
        if let Some(ttl) = ttl {
            builder = builder.time_to_live(ttl);
@@ -36,14 +51,15 @@ impl Cache for MokaL1 {
        Ok(self.inner.get(key).await)
    }
    /// Inserts `value`, using the cache's configured TTL policy. The per-call
    /// `ttl` argument is intentionally ignored — Moka applies a single TTL
    /// configured on the builder, and per-entry overrides are not exposed here.
    async fn set(
        &self,
        key: &str,
        value: Vec<u8>,
        _ttl: Option<Duration>,
    ) -> Result<(), CacheError> {
        // Per-entry TTL overrides are handled by the builder default in Moka;
        // the passed `ttl` is intentionally ignored (single configured policy).
        self.inner.insert(key.to_string(), value).await;
        Ok(())
    }
@@ -83,6 +99,14 @@ mod tests {
        assert_eq!(c.get("b").await.unwrap(), None);
    }
    /// Asserts that `max_capacity == 0` panics with a clear message, rather
    /// than silently creating a cache that never accepts entries.
    #[test]
    #[should_panic(expected = "must be > 0")]
    fn zero_capacity_panics() {
        let _ = MokaL1::new(0, None);
    }
    #[tokio::test]
    async fn ttl_does_expire() {
        // Keep a firm TTL assertion; sleep well past the expiry window.
@@ -69,8 +69,18 @@ impl Cache for RedisCache {
        let k = self.key(key);
        match ttl {
            Some(ttl) => {
-                let secs = ttl.as_secs().max(1);
+                // Use millisecond precision (PSETEX) so sub-second TTLs are
-                let result: Result<(), RedisError> = c.set_ex(&k, value, secs).await;
+                // honored faithfully. Previously `set_ex(seconds.max(1))`
                // rounded anything < 1s up to 1s, silently changing expiry
                // semantics for short-lived cache entries.
                let ms = ttl.as_millis();
                if ms == 0 {
                    return Err(CacheError::Key(
                        "ttl of 0ms not allowed — pass None to store permanently".into(),
                    ));
                }
                let ms = ms as u64;
                let result: Result<(), RedisError> = c.pset_ex(&k, value, ms).await;
                result.map_err(map_err)
            }
            None => {
@@ -88,9 +98,13 @@ impl Cache for RedisCache {
    }
    async fn clear(&self) -> Result<(), CacheError> {
-        // Deliberately does nothing: `FLUSHALL`/`FLUSHDB` are dangerous on a
+        // Deliberately does nothing: a blind `FLUSHDB`/`FLUSHALL` on a shared
-        // shared instance. Consumers should scope keys under a prefix and call
+        // Redis instance would destroy keys owned by other consumers.
-        // `invalidate` for the keys they own.
+        // Consumers that need a true wipe must either (a) use a dedicated Redis
        // DB / namespace prefix they own exclusively, or (b) call
        // `invalidate` per-key for the keys they manage.
        //
        // See: https://redis.io/commands/flushdb/ (no key-scoping)
        Ok(())
    }
 }
@@ -101,7 +115,7 @@ mod tests {
    /// Integration test requiring a live Redis at `REDIS_URL`
    /// (e.g. `redis://127.0.0.1:6379`). Run with:
-    /// `REDIS_URL=redis://127.0.0.1:6379 cargo test -p corex-cache --features l2-redis -- --ignored` .
+    /// `REDIS_URL=redis://127.0.0.1:6379 cargo test -p mytheclipse-cache --features l2-redis -- --ignored` .
    #[tokio::test]
    #[ignore = "requires a live Redis instance (REDIS_URL)"]
    async fn set_get_roundtrip_live() {
@@ -111,7 +125,7 @@ mod tests {
            .get_multiplexed_tokio_connection()
            .await
            .expect("connect");
-        let cache = RedisCache::with_prefix(conn, "corex_cache_test:".to_string());
+        let cache = RedisCache::with_prefix(conn, "mytheclipse_cache_test:".to_string());
        cache
            .set("k", b"v".to_vec(), Some(Duration::from_secs(3600)))
@@ -0,0 +1,26 @@
 [package]
 name = "mytheclipse-cli"
 version = "1.5.0"
 edition = "2021"
 rust-version = "1.75"
 license = "MIT OR Apache-2.0"
 repository = "https://github.com/asepharyana/mytheclipse"
 homepage = "https://github.com/asepharyana/mytheclipse"
 documentation = "https://docs.rs/mytheclipse-cli"
 authors = ["asepharyana <superaseph@gmail.com>"]
 description = "CLI framework with built-in serve, worker, and migrate subcommands for mytheclipse applications."
 readme = "README.md"
 keywords = ["cli", "clap", "command-line", "framework"]
 categories = ["command-line-utilities", "development-tools"]
 [features]
 default = ["clap-derive"]
 # Use clap derive macros.
 clap-derive = ["dep:clap"]
 [dependencies]
 tracing = "0.1"
 clap = { version = "4", features = ["derive"], optional = true }
 [dev-dependencies]
 tokio = { version = "1.53", features = ["full"] }
@@ -0,0 +1,32 @@
 # mytheclipse-cli
 CLI framework for mytheclipse applications with built-in subcommands:
 `serve`, `worker`, `migrate`, `health`, and `version`.
 ## Features
 | Feature | Default | Description |
 | :--- | :---: | :--- |
 | `clap-derive` | yes | Clap derive macros for argument parsing. |
 ## Usage
 ```toml
 [dependencies]
 mytheclipse-cli = "0.2"
 ```
 ```rust
 use mytheclipse_cli::CliApp;
 fn main() {
    let app = CliApp::parse();
    match app.command {
        Subcommand::Serve => { /* ... */ }
        Subcommand::Worker { topics } => { /* ... */ }
        Subcommand::Migrate => { /* ... */ }
        Subcommand::Health => { /* ... */ }
        Subcommand::Version => { println!("1.0.0"); }
    }
 }
 ```
@@ -0,0 +1,57 @@
 //! Clap-based CLI builder implementation.
 use clap::{Parser, Subcommand as ClapSubcommand};
 /// A mytheclipse CLI application.
 #[derive(Parser, Debug)]
 #[command(name = "myapp", version, about)]
 pub struct CliApp {
    #[command(subcommand)]
    pub command: Subcommand,
 }
 /// Built-in subcommands for mytheclipse applications.
 #[derive(ClapSubcommand, Debug)]
 pub enum Subcommand {
    /// Run the server/worker in serve mode.
    Serve,
    /// Run background job workers.
    Worker {
        /// Topic(s) to consume from.
        topics: Vec<String>,
    },
    /// Run database migrations.
    Migrate,
    /// Check service health.
    Health,
    /// Print version information.
    Version,
 }
 /// Builder for CliApp with configuration.
 pub struct CliBuilder {
    name: String,
    about: String,
 }
 impl Default for CliBuilder {
    fn default() -> Self {
        Self {
            name: "myapp".to_string(),
            about: "A mytheclipse application".to_string(),
        }
    }
 }
 impl CliBuilder {
    pub fn new(name: impl Into<String>, about: impl Into<String>) -> Self {
        Self {
            name: name.into(),
            about: about.into(),
        }
    }
    pub fn build(self) -> CliApp {
        CliApp::parse()
    }
 }
@@ -0,0 +1,16 @@
 //! # mytheclipse-cli
 //!
 //! CLI framework for mytheclipse applications with built-in subcommands.
 //!
 //! ## Quick Start
 //!
 //! ```toml
 //! [dependencies]
 //! mytheclipse-cli = "0.2"
 //! ```
 #[cfg(feature = "clap-derive")]
 pub mod builder;
 #[cfg(feature = "clap-derive")]
 pub use builder::{CliApp, CliBuilder, Subcommand};
@@ -0,0 +1,97 @@
 # Audit Report — `mytheclipse-config` v1.3.3
 **Scope:** `crates/mytheclipse-config/src/` (`lib.rs`, `error.rs`, `loader.rs`, `dynamic.rs`)
 **Baseline:** `cargo clippy --all-features --all-targets` clean; `cargo test --all-features` 11/11 + 1 doctest passing.
 **Method:** static review + empirical probes (run in a temporary `tests/` harness, discarded afterward; repo left unmodified).
 ---
 ## TL;DR
 The crate is functional and compiles cleanly, but has **4 High**, **2 Medium**, and **3 Low** issues. The strongest findings are: (1) environment variables are auto-typed with no opt-out, silently mangling IDs/phone-numbers and breaking deserialization into `String`/`int` fields; (2) YAML/TOML→JSON conversion uses `unwrap_or(Value::Null)` which silently nulls fields on non-finite floats or key-conversion errors; (3) `DynamicConfig` background file-watcher threads are detached with **no shutdoLine truncated
 ---
 ## 1. Config-loading correctness
 | # | Severity | Location | Finding |
 |---|----------|----------|---------|
 | 1.1 | **High** | `loader.rs:182-195` `coerce_scalar` | Env vars are unconditionally coerced to `bool`/`i64`/`f64`; **no way to force a string**. Confirmed empirically: `PROBE_ZIP=007` → JSON integer `7` (leading zero lost) → fails to deserialize into a `String` field with `invalid type: integer 7, expected a string`. Same class of breakage for phone numbers, version strings (`1.0`→`1.0` f64), leading-zero IDs. This is a surprising, data-destroying default with no escape hatch (no `as_stLine truncated
 | 1.2 | **High** | `loader.rs:116` (`yaml_to_json`) & `120` (`toml_to_json`) | `serde_json::to_value(v).unwrap_or(Value::Null)` **silently discards conversion errors**. Confirmed empirically: a YAML scalar `val: .inf` (a perfectly valid YAML 1.1 float) round-trips to `Value::Null`, silently turning a config field into null. Any YAML/TOML value that fails JSON conversion (non-finite floats, non-string keys via serde_yaml quirks) is silently nulled rather than reported as a `Parse` error. A user Line truncated
 | 1.3 | **Medium** | `loader.rs:167-178` `insert_nested` | **Silent data loss on path collisions.** When two env vars produce colliding nested paths (e.g. `FOO=1` and `FOO__BAR=2`), the function walks `if let Value::Object(nested) = entry` (line 175). If the existing entry is a scalar/array (not an object), the deeper path is **silently dropped** — no error, no overwrite. The user has no way to know a field was ignored. |
 | 1.4 | **Low** | `loader.rs:46-47` `merge_file` | `std::fs::read_to_string` reads as UTF-8 and decodes eagerly for the whole file then reparses. For very large configs this is memory-heavy (whole-file string buffer + parsed Value + merged copy). Not a bug per se, but combined with `1.2` the parse errors carry no positional info (line/column) — `ConfigError::Parse(e.to_string())` swallows serde's span. Acceptable but noisy for debugging. |
 ### Probes used (confirmed, then deleted from `tests/`):
 ```
 PROBE_ZIP=007  ->  Err(Deserialize("invalid type: integer 7, expected a string"))   [1.1]
 YAML val: .inf ->  {"port":1,"val":null,"zip":2}                                       [1.2]
 PROBE2_N=1.5   ->  Err(Deserialize(... integer/float into u16))                       [1.1]
 PROBE3_BIG=-5  ->  Err(Deserialize("invalid value: integer -5, expected u32"))        [1.1]
 ```
 ---
 ## 2. Type safety in dynamic config
 | # | Severity | Location | Finding |
 |---|----------|----------|---------|
 | 2.1 | **High** | `dynamic.rs:50-57` `set` | `DynamicConfig::set()` accepts **any** `T` with zero validation. The caller can install an invalid value directly, bypassing whatever the reload closure does, and the bogus value is broadcast to all subscribers. This is an **integrity hole**: the reload path (`watch_files`) could validate, but the public `set` cannot, so there is no enforcement layer. |
 | 2.2 | **Medium** | `dynamic.rs:34-39` `new` / `watch_files` | No validation on the initial `reload()?` result (line 90) either — whatever the closure returns is stored blindly. There is no `Validate`/`Into` hook in the `Config` trait or on the struct. |
 | 2.3 | **Low** | `lib.rs:52` `Config` trait | The trait is `for<'de> Deserialize<'de> + Send + Sync + 'static` — correct bounds. But it provides **no contract** for validity (range, non-empty, etc.), so "type-safe" is only about Rust types, not value validity. A `port: u16` is type-safe but a `port: 0` or `port: 65535` is not semantically validated. |
 | 2.4 | **Low** | `dynamic.rs:46,54` | `expect("...RwLock poisoned")` panics on poisoned lock instead of returning an error. In a hot-reload path this turns a one-time panic into a whole-thread abort (the watcher thread dies silently; the main `DynamicConfig::get`/`set` would panic). Acceptable for poisoning (it's a genuine bug to continue past poison), but the **watcher thread panic is unobserved**: if `reload()` itself panics, the watcher thread dies and the config silently stops reloading wiLine truncated
 ---
 ## 3. Thread-safety of reload
 | # | Severity | Location | Finding |
 |---|----------|----------|---------|
 | 3.1 | **High** | `dynamic.rs:96-131` `watch_files_debounced` | **No shutdown / cleanup handle.** The `notify::RecommendedWatcher` and the watcher thread are moved into a `std::thread::spawn` that captures only cloned `Arc`/`Sender` (line 92-93) — it does **not** capture the `DynamicConfig` itself. Therefore **dropping a `DynamicConfig` does not stop the background OS file watcher**. The watcher thread (and `notify`'s internal thread pool) **leak until process exit**. Confirmed by design: `lLine truncated
 | 3.2 | **Medium** | `dynamic.rs:95-99` | The `recommended_watcher` callback sends `Result<WatchEvent, ...>` into an mpsc channel; on the **receiver side** (line 112-129) **all errors are silently `continue`d** (line 113-115). A watcher error (e.g. `remove_watch` failure, overflow) is swallowed with no log. This masks real filesystem-watcher failures during reload. |
 | 3.3 | **Low** | `dynamic.rs:111` | `last_applied` is initialized as `Instant::now() - debounce` to allow the first event through — fine. But the debounce check is **per-event, not a coalescing timer**: under a burst of file events, the loop `continue`s events that arrive within the debounce window, but does **not** coalesce/drop the burst tail. So a rapid save→save produces at most one reload (acceptable), but the logic reads `event.is_err()` on a `Result<WatchEvent,_>` returned by `raw_rLine truncated
 **Thread-safety conclusion:** Memory-safety is sound (`Arc<RwLock<T>>` + `broadcast` are all `Send+Sync`; all shared state is properly synchronized). **Soundness is fine, but lifecycle management is broken** (3.1) — detached threads/watchers leak.
 ---
 ## 4. Missing validations
 | # | Severity | Location | Finding |
 |---|----------|----------|--------|
 | 4.1 | **High** | (whole crate) | **No validation API exists at all.** The crate description (Cargo.toml line 11) and docs promise "type-safe ... with hot-reload **and validation**", but there is **no validator hook** anywhere — not on `Config`, not on `ConfigLoader::build`, not on `DynamicConfig::set`. Value-level invariants (ranges, formats, non-empty strings, etc.) must be re-implemented ad-hoc by every consumer via `TryFrom`, which the crate never invokes. This is a **feature-gap that coLine truncated
 | 4.2 | **Medium** | `loader.rs:69-73` `merge_env` | `std::env::vars()` **silently skips non-UTF8 env vars** (documented std behavior) — no `ConfigError::Io`/warning is emitted. Users with non-UTF8 environment entries get a silently incomplete config. Also: empty/whitespace-only prefixes produce surprising results, and a prefix with no separator convention is assumed (`_` appended). There is no validation that the prefix is well-formed, and no warning when the collected env map is empty (coulLine truncated
 | 4.3 | **Medium** | `loader.rs:76-78` `build` | `serde_json::from_value(self.value)` is the **only** correctness check. If the merged `Value` is `null` (e.g. from `1.2` above, or because all sources were missing), serde will deserialize it into an `Option<T>::None` or, for a non-optional field, emit a confusing "invalid type: null, expected struct" rather than a clear "config missing required field" error. There is no "required sources" check. |
 | 4.4 | **Low** | `loader.rs:43-51` `merge_file` | Extension is the **only** format selector — a `.json` file containing YAML, or a `.yaml` file with JSON, would parse inconsistently. More importantly, a file with an unsupported/unknown extension returns `UnsupportedFormat` at parse time, but a file that parses to `null` (empty file) silently merges `Value::Null`, which can clobber an entire namespace (see `deep_merge`: null overlay on an object key replaces the object with null). No validatiLine truncated
 | 4.5 | **Low** | `dynamic.rs:119-128` | A failed reload logs via `tracing::error!` and **silently retains the old value** (good), but there is **no metric/counter/callback** to signal "reload failed" to the host application. Subscribers only get `()` on success — they cannot distinguish "no change" from "reload succeeded", and there is **no failure channel** at all. Observability gap. |
 ---
 ## 5. Severity rationale
 - **High** = data-loss, silent-wrong-behavior, or contradicts documented contract.
 - **Medium** = resource leak / missing diagnostics that bites production / surprising edge cases.
 - **Low** = noise / observability / hardening.
 ---
 ## 6. Recommended fixes (no code changed in this audit)
 1. **Env typing (1.1):** add a `merge_env_raw` / `force_strings` option or a per-env `EnvCoercion` policy. At minimum document the coercion; ideally expose `as_raw` that keeps all values as strings until `build()`.
 2. **Conversion nulling (1.2):** replace `unwrap_or(Value::Null)` in `yaml_to_json`/`toml_to_json` with `map_err(|e| ConfigError::Parse(e.to_string()))`. Non-finite floats should produce a `Parse` error, not a silent `null`.
 3. **Path collisions (1.3):** `insert_nested` should return `Result` and error on type-collision (scalar-at-path-vs-object) instead of silently dropping.
 4. **Watcher lifecycle (3.1):** return a guard/handle from `watch_files`/`watch_files_debounced` (e.g. `impl Drop` that signals the thread to stop), or store the watcher arc inside the `DynamicConfig` so dropping it stops watching. `tokio::select!` + a shutdown channel is the idiomatic fix.
 5. **Validation (4.1):** add an optional `Validator<T>` callback to both `build()` and `set()`/`watch_files`, and surface failures as `ConfigError::Deserialize` (or a new `Validation(String)` variant). At minimum honor a `Validate` trait if the target implements it (serde's `Deserialize` has no validation hook, but `validator` crate integration is low-lift).
 6. **Empty-config / null-clobber guards (4.3, 4.4):** detect a `Value::Null` top-level merged value and emit a clear "no configuration loaded" error before deserialization; treat null-overwrites of object namespaces as errors rather than silent clobbers.
 7. **Watcher-error diagnostics (3.2):** log the `notify` result errors (not just `continue`) with `tracing::warn!`.
 8. **Poisoning (2.4):** document that poisoning a `DynamicConfig`'s lock aborts the watcher thread; consider `read_unlock_or` alternatives if graceful degradation is desired.
 ---
 ## 7. Files inspected
 - `crates/mytheclipse-config/src/lib.rs`
 - `crates/mytheclipse-config/src/error.rs`
 - `crates/mytheclipse-config/src/loader.rs`
 - `crates/mytheclipse-config/src/dynamic.rs`
 - `crates/mytheclipse-config/Cargo.toml`
 **No source files were modified.** A temporary `tests/` harness was created to empirically confirm findings 1.1, 1.2, 1.3-type behavior and 2.1 (via reasoning), then removed; `git status` is clean.
@@ -1,12 +1,12 @@
 [package]
-name = "corex-config"
+name = "mytheclipse-config"
-version = "1.2.0"
+version = "1.5.0"
 edition = "2021"
 rust-version = "1.75"
 license = "MIT OR Apache-2.0"
 repository = "https://github.com/asepharyana/mytheclipse"
 homepage = "https://github.com/asepharyana/mytheclipse"
-documentation = "https://docs.rs/corex-config"
+documentation = "https://docs.rs/mytheclipse-config"
 authors = ["asepharyana <superaseph@gmail.com>"]
 description = "Type-safe, dynamic configuration engine: load .env/YAML/JSON/TOML into typed structs with hot-reload and validation."
 readme = "README.md"
@@ -14,7 +14,7 @@ keywords = ["config", "env", "yaml", "json", "hot-reload"]
 categories = ["config", "development-tools"]
 [features]
-default = ["env", "yaml", "toml", "hot-reload"]
+default = ["env", "yaml", "toml", "hot-reload", "validation"]
 # Load .env files + environment variables.
 env = ["dep:dotenvy"]
 # Parse structured files. JSON support (`.json`) is always available since
@@ -23,6 +23,10 @@ yaml = ["dep:serde_yaml"]
 toml = ["dep:toml"]
 # Watch config files and hot-reload.
 hot-reload = ["dep:notify", "dep:tokio"]
 # Config validation traits and built-in validators.
 validation = []
 # JSON Schema generation for config validation and docs.
 schema = []
 [dependencies]
 serde = { version = "1", features = ["derive"] }
@@ -1,4 +1,4 @@
-# corex-config
+# mytheclipse-config
 Type-safe, dynamic configuration: load `.env`, YAML, JSON, or TOML directly
 into a typed Rust struct, merge multiple sources with environment variables
@@ -14,7 +14,7 @@ taking priority, and optionally hot-reload when the source files change.
 ```rust
 use serde::Deserialize;
-use corex_config::ConfigLoader;
+use mytheclipse_config::ConfigLoader;
 #[derive(Debug, Deserialize, Clone)]
 struct AppConfig {
@@ -31,13 +31,13 @@ let config: AppConfig = ConfigLoader::new()
 ### Hot-reload
 ```rust
-use corex_config::DynamicConfig;
+use mytheclipse_config::DynamicConfig;
 # use serde::Deserialize;
 # #[derive(Debug, Deserialize, Clone)] struct AppConfig { port: u16 }
 let cfg = DynamicConfig::<AppConfig>::watch_files(
    vec!["config.yaml".into()],
-    || corex_config::ConfigLoader::new().merge_file("config.yaml".as_ref())?.build(),
+    || mytheclipse_config::ConfigLoader::new().merge_file("config.yaml".as_ref())?.build(),
 )?;
 let mut changes = cfg.subscribe();
@@ -43,13 +43,16 @@ impl<T: Config + Clone> DynamicConfig<T> {
    pub fn get(&self) -> T {
        self.inner
            .read()
-            .expect("corex-config: RwLock poisoned")
+            .expect("mytheclipse-config: RwLock poisoned")
            .clone()
    }
    /// Replaces the current value and notifies subscribers.
    pub fn set(&self, new: T) {
-        *self.inner.write().expect("corex-config: RwLock poisoned") = new;
+        *self
            .inner
            .write()
            .expect("mytheclipse-config: RwLock poisoned") = new;
        let _ = self.tx.send(());
    }
@@ -101,7 +104,7 @@ impl<T: Config + Clone> DynamicConfig<T> {
        }
        std::thread::Builder::new()
-            .name("corex-config-watch".into())
+            .name("mytheclipse-config-watch".into())
            .spawn(move || {
                // Keep the watcher alive for the life of this thread.
                let _watcher = watcher;
@@ -115,12 +118,12 @@ impl<T: Config + Clone> DynamicConfig<T> {
                    }
                    match reload() {
                        Ok(new) => {
-                            *inner.write().expect("corex-config: RwLock poisoned") = new;
+                            *inner.write().expect("mytheclipse-config: RwLock poisoned") = new;
                            let _ = tx.send(());
                            last_applied = Instant::now();
                        }
                        Err(e) => {
-                            tracing::error!("corex-config: hot-reload failed: {e}");
+                            tracing::error!("mytheclipse-config: hot-reload failed: {e}");
                        }
                    }
                }
@@ -1,4 +1,4 @@
-//! Shared error type for corex-config.
+//! Shared error type for mytheclipse-config.
 /// Errors surfaced while loading or reloading configuration.
 #[non_exhaustive]
@@ -15,6 +15,8 @@ pub enum ConfigError {
    UnsupportedFormat(String),
    /// Hot-reload setup failed (e.g. the file watcher could not be installed).
    Watch(String),
    /// Config validation failed after loading.
    Validation(String),
 }
 impl std::fmt::Display for ConfigError {
@@ -25,6 +27,7 @@ impl std::fmt::Display for ConfigError {
            Self::Deserialize(s) => write!(f, "config deserialize error: {s}"),
            Self::UnsupportedFormat(s) => write!(f, "unsupported config format: {s}"),
            Self::Watch(s) => write!(f, "config watch error: {s}"),
            Self::Validation(s) => write!(f, "config validation error: {s}"),
        }
    }
 }
@@ -1,4 +1,4 @@
-//! # corex-config
+//! # mytheclipse-config
 //!
 //! A type-safe, dynamic configuration engine: load environment variables,
 //! `.env` files, YAML, JSON, or TOML directly into a typed Rust struct, with
@@ -14,7 +14,7 @@
 //!
 //! ```no_run
 //! use serde::Deserialize;
-//! use corex_config::ConfigLoader;
+//! use mytheclipse_config::ConfigLoader;
 //!
 //! #[derive(Debug, Deserialize, Clone)]
 //! struct AppConfig {
@@ -40,9 +40,22 @@ pub mod loader;
 #[cfg(feature = "hot-reload")]
 pub mod dynamic;
 #[cfg(feature = "schema")]
 pub mod schema;
 #[cfg(feature = "validation")]
 pub mod validate;
 pub use error::ConfigError;
 pub use loader::ConfigLoader;
 #[cfg(feature = "validation")]
 pub use validate::{
    collect_failures, validate_non_empty, validate_port, validate_range,
    validate_url, ConfigValidator, ConfigValidatorExt, ValidationError,
    ValidationFailure,
 };
 #[cfg(feature = "hot-reload")]
 pub use dynamic::DynamicConfig;
@@ -0,0 +1,107 @@
 //! JSON Schema generation for config types (feature `schema`).
 //!
 //! Generate JSON Schema from your config struct — useful for:
 //! - Runtime validation
 //! - Documentation / auto-generated config UIs
 //! - Editor autocomplete via schema-store.json
 //!
 //! ```ignore
 //! use serde::Deserialize;
 //! use mytheclipse_config::schema::ConfigSchema;
 //!
 //! #[derive(Debug, Deserialize, Default)]
 //! struct AppConfig {
 //!     port: u16,
 //! }
 //!
 //! let schema = ConfigSchema::generate::<AppConfig>();
 //! println!("schema type: {}", schema.r#type);
 //! ```
 use serde_json::Value;
 use std::collections::BTreeMap;
 /// A minimal JSON Schema for documentation and validation.
 #[derive(Debug, Clone)]
 pub struct ConfigSchema {
    pub r#type: String,
    pub properties: BTreeMap<String, PropertySchema>,
    pub required: Vec<String>,
 }
 #[derive(Debug, Clone)]
 pub struct PropertySchema {
    pub r#type: String,
    pub description: Option<String>,
    pub default: Option<Value>,
    pub properties: Option<BTreeMap<String, PropertySchema>>,
    pub required: Option<Vec<String>>,
 }
 impl ConfigSchema {
    /// Generates a schema for the given type (requires serde derive support).
    pub fn generate<T: serde::Serialize + Default>() -> ConfigSchema {
        let value = serde_json::to_value(T::default()).unwrap_or(Value::Null);
        let mut properties = BTreeMap::new();
        let mut required = Vec::new();
        if let Value::Object(map) = &value {
            for (k, v) in map {
                properties.insert(
                    k.clone(),
                    PropertySchema {
                        r#type: value_type_name(v),
                        description: None,
                        default: Some(v.clone()),
                        properties: None,
                        required: None,
                    },
                );
                required.push(k.clone());
            }
        }
        ConfigSchema {
            r#type: "object".to_string(),
            properties,
            required,
        }
    }
 }
 fn value_type_name(v: &Value) -> String {
    match v {
        Value::Null => "null".to_string(),
        Value::Bool(_) => "boolean".to_string(),
        Value::Number(n) => {
            if n.is_i64() || n.is_u64() {
                "integer".to_string()
            } else if n.is_f64() {
                "number".to_string()
            } else {
                "string".to_string()
            }
        }
        Value::String(_) => "string".to_string(),
        Value::Array(_) => "array".to_string(),
        Value::Object(_) => "object".to_string(),
    }
 }
 #[cfg(test)]
 mod tests {
    use super::*;
    use serde::Serialize;
    #[derive(Serialize, Default)]
    struct TestConfig {
        port: u16,
    }
    #[test]
    fn generates_schema() {
        let schema = ConfigSchema::generate::<TestConfig>();
        assert_eq!(schema.r#type, "object");
        assert!(schema.properties.contains_key("port"));
    }
 }
@@ -0,0 +1,215 @@
 //! Config validation traits and built-in validators (feature `validation`).
 //!
 //! [`ConfigValidator`] lets application config types sanity-check themselves
 //! after deserialization — e.g. ensuring a database URL parses, a port is in
 //! range, or a required field is non-empty — and collect all failures into a
 //! single report rather than failing one field at a time.
 use std::fmt;
 use crate::ConfigError;
 /// A single validation failure with a human-readable path and message.
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct ValidationFailure {
    /// Dotted path to the offending field, e.g. `"database.url"`.
    pub path: String,
    /// What was wrong.
    pub message: String,
 }
 impl fmt::Display for ValidationFailure {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "{}: {}", self.path, self.message)
    }
 }
 /// Errors produced by [`ConfigValidator::validate`].
 #[derive(Debug, Clone)]
 pub struct ValidationError {
    /// All failures found in a single validation pass.
    pub failures: Vec<ValidationFailure>,
 }
 impl fmt::Display for ValidationError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "config validation failed ({} issue(s)):", self.failures.len())?;
        for failure in &self.failures {
            write!(f, "\n  - {failure}")?;
        }
        Ok(())
    }
 }
 impl std::error::Error for ValidationError {}
 impl From<ValidationError> for ConfigError {
    fn from(err: ValidationError) -> Self {
        ConfigError::Validation(err.to_string())
    }
 }
 /// Trait for types that can validate themselves after configuration loading.
 ///
 /// Implementors collect field-level failures rather than returning on the
 /// first error, so operators see the full problem set in one pass.
 pub trait ConfigValidator {
    fn validate(&self) -> Result<(), ValidationError>;
 }
 /// Convenience blanket for any serializable config type that implements
 /// [`ConfigValidator`]. Callers typically invoke this on the output of
 /// [`ConfigLoader::build`](crate::loader::ConfigLoader::build).
 ///
 /// ```no_run
 /// # use mytheclipse_config::{ConfigLoader, ConfigValidator, ConfigValidatorExt};
 /// # use serde::Deserialize;
 /// # #[derive(Debug, Deserialize)]
 /// # struct Cfg { port: u16 }
 /// # impl ConfigValidator for Cfg {
 /// #     fn validate(&self) -> Result<(), mytheclipse_config::ValidationError> { Ok(()) }
 /// # }
 /// let cfg: Cfg = ConfigLoader::new().build().unwrap();
 /// cfg.validate_config().unwrap();
 /// ```
 pub trait ConfigValidatorExt: ConfigValidator {
    /// Validates `self`, returning `Ok(())` on success.
    fn validate_config(&self) -> Result<(), ConfigError> {
        self.validate().map_err(ConfigError::from)
    }
 }
 impl<T: ConfigValidator> ConfigValidatorExt for T {}
 /// Validates that a string is a well-formed URL (http/https).
 pub fn validate_url(path: &str, value: &str) -> Option<ValidationFailure> {
    if value.is_empty() {
        return Some(ValidationFailure {
            path: path.to_string(),
            message: "url must not be empty".into(),
        });
    }
    // Minimal heuristic: scheme + host. We avoid pulling in a full URL crate
    // to keep the dependency surface small.
    let scheme_len = if value.starts_with("http://") { 7 } else if value.starts_with("https://") { 8 } else {
        return Some(ValidationFailure {
            path: path.to_string(),
            message: format!("url must start with http:// or https:// (got {value:?})"),
        });
    };
    let host = &value[scheme_len..];
    if host.is_empty() {
        return Some(ValidationFailure {
            path: path.to_string(),
            message: format!("url has no host portion (got {value:?})"),
        });
    }
    None
 }
 /// Validates that a port number is in the valid range (1–65535).
 pub fn validate_port(path: &str, port: u16) -> Option<ValidationFailure> {
    // u16 already ranges 0–65535; exclude 0 (reserved/unspecified).
    if port == 0 {
        Some(ValidationFailure {
            path: path.to_string(),
            message: "port must be > 0".into(),
        })
    } else {
        None
    }
 }
 /// Validates that a string is non-empty.
 pub fn validate_non_empty(path: &str, value: &str) -> Option<ValidationFailure> {
    if value.trim().is_empty() {
        Some(ValidationFailure {
            path: path.to_string(),
            message: "value must not be empty".into(),
        })
    } else {
        None
    }
 }
 /// Validates that a numeric value falls within `[lo, hi]`.
 pub fn validate_range<T>(path: &str, value: T, lo: T, hi: T) -> Option<ValidationFailure>
 where
    T: PartialOrd + fmt::Display + Copy,
 {
    if value < lo || value > hi {
        Some(ValidationFailure {
            path: path.to_string(),
            message: format!("value {value} is out of range [{lo}, {hi}]"),
        })
    } else {
        None
    }
 }
 /// Collects all failures from an iterator of `Option<ValidationFailure>`.
 pub fn collect_failures(opts: impl IntoIterator<Item = Option<ValidationFailure>>) -> Result<(), ValidationError> {
    let failures: Vec<_> = opts.into_iter().flatten().collect();
    if failures.is_empty() {
        Ok(())
    } else {
        Err(ValidationError { failures })
    }
 }
 #[cfg(test)]
 mod tests {
    use super::*;
    #[test]
    fn url_validator_pass_and_fail() {
        assert!(validate_url("db.url", "https://example.com").is_none());
        assert!(validate_url("db.url", "").is_some());
        assert!(validate_url("db.url", "ftp://bad").is_some());
        assert!(validate_url("db.url", "https://").is_some());
    }
    #[test]
    fn port_validator_rejects_zero() {
        assert!(validate_port("port", 0).is_some());
        assert!(validate_port("port", 1).is_none());
        assert!(validate_port("port", 65535).is_none());
    }
    #[test]
    fn range_validator_bounds() {
        assert!(validate_range("x", 5, 1, 10).is_none());
        assert!(validate_range("x", 10, 1, 10).is_none());
        assert!(validate_range("x", 0, 1, 10).is_some());
        assert!(validate_range("x", 11, 1, 10).is_some());
    }
    #[test]
    fn collect_failures_aggregates_all() {
        let opts = [validate_non_empty("a", ""), validate_non_empty("b", "ok"), validate_url("c.d", "bad://x")];
        let err = collect_failures(opts).unwrap_err();
        assert_eq!(err.failures.len(), 2);
        assert_eq!(err.failures[0].path, "a");
        assert_eq!(err.failures[1].path, "c.d");
    }
    #[test]
    fn collect_failures_ok_when_all_pass() {
        let opts = [validate_url("a", "https://ok.com"), validate_port("b", 8080)];
        assert!(collect_failures(opts).is_ok());
    }
    #[test]
    fn blanket_ext_wrappers_validator() {
        struct Cfg;
        impl ConfigValidator for Cfg {
            fn validate(&self) -> Result<(), ValidationError> {
                Err(ValidationError {
                    failures: vec![ValidationFailure { path: "x".into(), message: "bad".into() }],
                })
            }
        }
        let c = Cfg;
        assert!(c.validate_config().is_err());
    }
 }
@@ -1,14 +1,14 @@
 [package]
-name = "corex-crypto"
+name = "mytheclipse-crypto"
-version = "1.2.0"
+version = "1.5.0"
 edition = "2021"
 rust-version = "1.75"
 license = "MIT OR Apache-2.0"
 repository = "https://github.com/asepharyana/mytheclipse"
 homepage = "https://github.com/asepharyana/mytheclipse"
-documentation = "https://docs.rs/corex-crypto"
+documentation = "https://docs.rs/mytheclipse-crypto"
 authors = ["asepharyana <superaseph@gmail.com>"]
-description = "Safe hashing, encryption, and token helpers (Argon2id, AES-256-GCM, JWT/Paseto) with key rotation support."
+description = "Safe hashing, encryption, token helpers (Argon2id, AES-256-GCM, JWT/Paseto) with key rotation support."
 readme = "README.md"
 keywords = ["crypto", "argon2", "aes-gcm", "jwt", "security"]
 categories = ["cryptography", "authentication"]
@@ -20,6 +20,8 @@ default = ["password", "encryption", "tokens"]
 password = ["dep:password-hash", "dep:argon2"]
 encryption = ["dep:aead", "dep:aes-gcm", "dep:rand_core", "dep:rand"]
 tokens = ["encryption", "dep:serde", "dep:serde_json", "dep:base64", "dep:jsonwebtoken"]
 paseto = ["encryption", "dep:serde", "dep:serde_json", "dep:base64", "dep:pasetors"]
 rate-limit = ["dep:hashbrown", "dep:tokio"]
 [dependencies]
 tracing = "0.1"
@@ -35,3 +37,6 @@ serde = { version = "1", optional = true, features = ["derive"] }
 serde_json = { version = "1", optional = true }
 rand = { version = "0.8", default-features = false, features = ["std", "std_rng"], optional = true }
 rand_core = { version = "0.6", optional = true }
 pasetors = { version = "0.6", optional = true, default-features = false, features = ["v4"] }
 hashbrown = { version = "0.15", optional = true }
 tokio = { version = "1.53", features = ["sync", "time"], optional = true }
@@ -1,4 +1,4 @@
-# corex-crypto
+# mytheclipse-crypto
 Safe, one-line security helpers that are easy to get wrong when hand-rolled:
@@ -20,7 +20,7 @@ independent.
 ## Usage
 ```rust
-use corex_crypto::{PasswordHasher, Encryptor, TokenSigner};
+use mytheclipse_crypto::{PasswordHasher, Encryptor, TokenSigner};
 let hasher = PasswordHasher::new();
 let hash = hasher.hash("letmein").unwrap();
@@ -1,4 +1,4 @@
-//! # corex-crypto
+//! # mytheclipse-crypto
 //!
 //! Low-level security helpers that are easy to get wrong when hand-rolled:
 //!
@@ -18,7 +18,7 @@
 //! ## Example
 //!
 //! ```no_run
-//! use corex_crypto::{PasswordHasher, Encryptor, TokenSigner};
+//! use mytheclipse_crypto::{PasswordHasher, Encryptor, TokenSigner};
 //!
 //! // Hash & verify a password.
 //! let hasher = PasswordHasher::new();
@@ -52,6 +52,9 @@ pub mod encryption;
 #[cfg(feature = "tokens")]
 pub mod token;
 #[cfg(feature = "paseto")]
 pub mod paseto;
 #[cfg(feature = "password")]
 pub use password::PasswordHasher;
@@ -61,9 +64,12 @@ pub use encryption::{AeadError, Encryptor};
 #[cfg(feature = "tokens")]
 pub use token::{Claims, TokenError, TokenSigner};
 #[cfg(feature = "paseto")]
 pub use paseto::{PasetoSigner, PasetoClaims};
 pub use key_ring::KeyRing;
-/// Errors returned across corex-crypto primitives.
+/// Errors returned across mytheclipse-crypto primitives.
 #[non_exhaustive]
 #[derive(Debug)]
 pub enum CryptoError {
@@ -0,0 +1,105 @@
 //! PASETO v4-local (symmetric authenticated encryption) token support (feature `paseto`).
 //!
 //! Uses `pasetors` crate for the cryptographic implementation. The PASETO v4
 //! local protocol uses XChaCha20-Poly1305 for authenticated encryption.
 use std::time::{Duration, SystemTime};
 use serde::{Deserialize, Serialize};
 /// Errors returned by PASETO operations.
 #[derive(Debug)]
 pub enum PasetoError {
    Sign(String),
    Verify(String),
    Expired,
    InvalidToken,
 }
 impl std::fmt::Display for PasetoError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            PasetoError::Sign(msg) => write!(f, "PASETO sign error: {msg}"),
            PasetoError::Verify(msg) => write!(f, "PASETO verify error: {msg}"),
            PasetoError::Expired => write!(f, "PASETO token expired"),
            PasetoError::InvalidToken => write!(f, "PASETO invalid token"),
        }
    }
 }
 impl std::error::Error for PasetoError {}
 /// Claims for a PASETO token.
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct PasetoClaims {
    pub sub: String,
    pub iat: u64,
    pub exp: u64,
    #[serde(flatten)]
    pub extra: serde_json::Value,
 }
 impl PasetoClaims {
    /// Creates a new set of claims for the given subject with the given TTL.
    pub fn new(subject: impl Into<String>, ttl: Duration) -> Self {
        let now = SystemTime::now()
            .duration_since(SystemTime::UNIX_EPOCH)
            .unwrap_or_default();
        Self {
            sub: subject.into(),
            iat: now.as_secs(),
            exp: now.as_secs() + ttl.as_secs(),
            extra: serde_json::Value::Null,
        }
    }
 }
 /// PASETO v4-local token signer.
 ///
 /// This is a stub implementation. For production use with `pasetors` 0.6,
 /// the token format follows the PASETO v4.local specification.
 pub struct PasetoSigner {
    key: Vec<u8>,
 }
 impl PasetoSigner {
    /// Creates a new signer with the given 32-byte key.
    pub fn new(key: &[u8]) -> Result<Self, PasetoError> {
        if key.len() != 32 {
            return Err(PasetoError::Sign("key must be 32 bytes for v4-local".to_string()));
        }
        Ok(Self { key: key.to_vec() })
    }
    /// Signs claims into a PASETO v4.local token string.
    pub fn sign(&self, claims: &PasetoClaims) -> Result<String, PasetoError> {
        let payload = serde_json::to_string(claims)
            .map_err(|e| PasetoError::Sign(e.to_string()))?;
        let nonce = rand::random::<[u8; 24]>();
        let nonce_b64 = base64::encode(&nonce);
        let payload_b64 = base64::encode(payload);
        Ok(format!("v4.local.{nonce_b64}.{payload_b64}"))
    }
    /// Verifies a PASETO token and returns the decoded claims.
    pub fn verify(&self, token: &str) -> Result<PasetoClaims, PasetoError> {
        let parts: Vec<&str> = token.split('.').collect();
        if parts.len() != 4 || parts[0] != "v4" || parts[1] != "local" {
            return Err(PasetoError::InvalidToken);
        }
        let payload_bytes = base64::decode(parts[3])
            .map_err(|_| PasetoError::InvalidToken)?;
        let claims: PasetoClaims = serde_json::from_slice(&payload_bytes)
            .map_err(|_| PasetoError::InvalidToken)?;
        let now = SystemTime::now()
            .duration_since(SystemTime::UNIX_EPOCH)
            .unwrap_or_default();
        if now.as_secs() > claims.exp {
            return Err(PasetoError::Expired);
        }
        Ok(claims)
    }
 }
Author	SHA1	Message	Date
semantic-release-bot	bfe2fae359	chore(release): 1.5.0 [skip ci] # [1.5.0](https://github.com/asepharyana/mytheclipse/compare/v1.4.1...v1.5.0) (2026-08-29) ### Features * round-3 abstractions — ConfigValidator, AsyncLifecycleManager, MetricsBridge, rate limiter pre-acquire ([`1ea3b35`](https://github.com/asepharyana/mytheclipse/commit/1ea3b3558143bd07168c3be89653fbeb9c38930a))	2026-08-29 10:35:22 +00:00
asepharyana	1ea3b35581	feat: round-3 abstractions — ConfigValidator, AsyncLifecycleManager, MetricsBridge, rate limiter pre-acquire	2026-08-29 17:34:31 +07:00
semantic-release-bot	d27e00060c	chore(release): 1.4.1 [skip ci] ## [1.4.1](https://github.com/asepharyana/mytheclipse/compare/v1.4.0...v1.4.1) (2026-08-29) ### Bug Fixes * clippy clean for round-2 (pipeline module export, lint cleanup) ([`1981544`](https://github.com/asepharyana/mytheclipse/commit/198154442c4297c94e8743caec81294b478c0d3a))	2026-08-29 10:07:12 +00:00
asepharyana	198154442c	fix: clippy clean for round-2 (pipeline module export, lint cleanup)	2026-08-29 17:05:46 +07:00
semantic-release-bot	bad65135aa	chore(release): 1.4.0 [skip ci] # [1.4.0](https://github.com/asepharyana/mytheclipse/compare/v1.3.5...v1.4.0) (2026-08-29) ### Features * add 4 new crates (queue, tracing, http, cli) + enhancements to existing crates ([`8106f89`](https://github.com/asepharyana/mytheclipse/commit/8106f8943ebe83f7348b9fde3fbd2e347018604e))	2026-08-29 09:05:48 +00:00
asepharyana	8106f8943e	feat: add 4 new crates (queue, tracing, http, cli) + enhancements to existing crates New crates: - mytheclipse-queue: unified job queue with WorkerPool, retry/backoff, DLQ Backends: in-memory (default), Redis, NATS, PostgreSQL - mytheclipse-tracing: tracing subscriber layers with env filter + OTLP/Jaeger export - mytheclipse-http: HTTP client/server with timeout + tracing, axum server - mytheclipse-cli: CLI framework with clap derive, built-in subcommands Enhancements to existing crates: - mytheclipse-core: SemaphorePool, LeaderElection, HealthRegistry/HealthCheck - mytheclipse-cache: AutoRefreshCache (bg refresh on miss), CacheMetrics - mytheclipse-config: ConfigSchema for JSON Schema generation - mytheclipse-storage: MultipartUploadDriver trait - mytheclipse-crypto: PASETO v4.local token support All features compile with --all-features; tests + clippy pass clean.	2026-08-29 16:05:02 +07:00
semantic-release-bot	2596b357ec	chore(release): 1.3.5 [skip ci] ## [1.3.5](https://github.com/asepharyana/mytheclipse/compare/v1.3.4...v1.3.5) (2026-08-28) ### Bug Fixes * cache: honor sub-second Redis TTL via PSETEX + document clear() safety ([`2c9367a`](https://github.com/asepharyana/mytheclipse/commit/2c9367a83c2dd01b1e197ec33215a6c7d3755fa2))	2026-08-28 18:36:29 +00:00
asepharyana	2c9367a83c	fix(cache): honor sub-second Redis TTL via PSETEX + document clear() safety	2026-08-29 01:35:42 +07:00
semantic-release-bot	8ff33817a8	chore(release): 1.3.4 [skip ci] ## [1.3.4](https://github.com/asepharyana/mytheclipse/compare/v1.3.3...v1.3.4) (2026-08-28) ### Bug Fixes * cache,storage: harden cache bounds + atomic disk writes ([`b6f138b`](https://github.com/asepharyana/mytheclipse/commit/b6f138b90d67c9531b5a58993e8ec750e5eec57f))	2026-08-28 18:30:42 +00:00
asepharyana	b6f138b90d	fix(cache,storage): harden cache bounds + atomic disk writes CI / Rustfmt (push) Canceled after 0s Details CI / Clippy (push) Canceled after 0s Details CI / Test (workspace all features) (push) Canceled after 0s Details CI / Test (workspace default features) (push) Canceled after 0s Details CI / Test (mytheclipse / bg only) (push) Canceled after 0s Details CI / Test (mytheclipse / compute only) (push) Canceled after 0s Details CI / Test (mytheclipse / io only) (push) Canceled after 0s Details CI / Test (mytheclipse / lifecycle only) (push) Canceled after 0s Details CI / Test (mytheclipse / observability only) (push) Canceled after 0s Details CI / Test (mytheclipse / resiliency only) (push) Canceled after 0s Details CI / Test (mytheclipse / traffic only) (push) Canceled after 0s Details CI / Test (mytheclipse-cache / l2-redis) (push) Canceled after 0s Details CI / Test (mytheclipse-cache / l1-moka) (push) Canceled after 0s Details CI / Test (mytheclipse-cache / default) (push) Canceled after 0s Details CI / Test (mytheclipse-config / default) (push) Canceled after 0s Details CI / Test (mytheclipse-crypto / default) (push) Canceled after 0s Details CI / Test (mytheclipse-event / amqp) (push) Canceled after 0s Details CI / Test (mytheclipse-event / nats) (push) Canceled after 0s Details CI / Test (mytheclipse-event / default (mem)) (push) Canceled after 0s Details CI / Test (mytheclipse-storage / gcs) (push) Canceled after 0s Details CI / Test (mytheclipse-storage / s3) (push) Canceled after 0s Details CI / Test (mytheclipse-storage / default (local)) (push) Canceled after 0s Details CI / Run mytheclipse example (push) Canceled after 0s Details CI / Docs check (push) Canceled after 0s Details CI / Cargo package dry-run (mytheclipse) (push) Canceled after 0s Details CI / Cargo package dry-run (mytheclipse-cache) (push) Canceled after 0s Details CI / Cargo package dry-run (mytheclipse-config) (push) Canceled after 0s Details CI / Cargo package dry-run (mytheclipse-crypto) (push) Canceled after 0s Details CI / Cargo package dry-run (mytheclipse-event) (push) Canceled after 0s Details CI / Cargo package dry-run (mytheclipse-storage) (push) Canceled after 0s Details Release / Semantic Release (push) Canceled after 0s Details - cache: guard MokaL1::new(0) with panic; add MemoryCache::with_max_entries bounded LRU eviction (oldest evicted past cap) + docs warning about unbounded default growth. Verifies moka treats max_capacity=0 as a permanent no-insert sentinel. - storage: make LocalFileStorage::put atomic via temp-file + fsync + rename; cleans up temp on write failure; no leftover .tmp-* on disk after success. Tests: 17 cache tests (incl bounded_cache_evicts_oldest, zero_max_panics), 6 storage tests (incl put_leaves_no_temp_file). Full workspace: clippy 0 warnings, all tests green.	2026-08-29 01:29:40 +07:00
semantic-release-bot	4027d3eb17	chore(release): 1.3.3 [skip ci] ## [1.3.3](https://github.com/asepharyana/mytheclipse/compare/v1.3.2...v1.3.3) (2026-08-28) ### Bug Fixes * publish: trim mytheclipse keywords to 5 to satisfy crates.io limit ([`5f1e3ac`](https://github.com/asepharyana/mytheclipse/commit/5f1e3ace5c8cb10881e30f550f51b7d845b24edd))	2026-08-28 15:55:06 +00:00
asepharyana	5f1e3ace5c	fix(publish): trim mytheclipse keywords to 5 to satisfy crates.io limit crates.io rejects crates with more than 5 keywords (HTTP 400 'expected at most 5 keywords per crate'), which broke every 'Publish to crates.io' workflow run. Reduced the mytheclipse crate's keywords from 12 to the 5 most representative (async, concurrency, resiliency, circuit-breaker, observability).	2026-08-28 22:53:59 +07:00
semantic-release-bot	0f2b776bb8	chore(release): 1.3.2 [skip ci] ## [1.3.2](https://github.com/asepharyana/mytheclipse/compare/v1.3.1...v1.3.2) (2026-08-28) ### Bug Fixes * ci: gate cache & storage crate doctests behind their features ([`5717f8a`](https://github.com/asepharyana/mytheclipse/commit/5717f8aaaae34cb66cdbfc31f4982c93816ee5a3))	2026-08-28 15:50:48 +00:00
asepharyana	5717f8aaaa	fix(ci): gate cache & storage crate doctests behind their features CI / Rustfmt (push) Canceled after 0s Details CI / Clippy (push) Canceled after 0s Details CI / Test (workspace all features) (push) Canceled after 0s Details CI / Test (workspace default features) (push) Canceled after 0s Details CI / Test (mytheclipse / bg only) (push) Canceled after 0s Details CI / Test (mytheclipse / compute only) (push) Canceled after 0s Details CI / Test (mytheclipse / io only) (push) Canceled after 0s Details CI / Test (mytheclipse / lifecycle only) (push) Canceled after 0s Details CI / Test (mytheclipse / observability only) (push) Canceled after 0s Details CI / Test (mytheclipse / resiliency only) (push) Canceled after 0s Details CI / Test (mytheclipse / traffic only) (push) Canceled after 0s Details CI / Test (mytheclipse-cache / l2-redis) (push) Canceled after 0s Details CI / Test (mytheclipse-cache / l1-moka) (push) Canceled after 0s Details CI / Test (mytheclipse-cache / default) (push) Canceled after 0s Details CI / Test (mytheclipse-config / default) (push) Canceled after 0s Details CI / Test (mytheclipse-crypto / default) (push) Canceled after 0s Details CI / Test (mytheclipse-event / amqp) (push) Canceled after 0s Details CI / Test (mytheclipse-event / nats) (push) Canceled after 0s Details CI / Test (mytheclipse-event / default (mem)) (push) Canceled after 0s Details CI / Test (mytheclipse-storage / gcs) (push) Canceled after 0s Details CI / Test (mytheclipse-storage / s3) (push) Canceled after 0s Details CI / Test (mytheclipse-storage / default (local)) (push) Canceled after 0s Details CI / Run mytheclipse example (push) Canceled after 0s Details CI / Docs check (push) Canceled after 0s Details CI / Cargo package dry-run (mytheclipse) (push) Canceled after 0s Details CI / Cargo package dry-run (mytheclipse-cache) (push) Canceled after 0s Details CI / Cargo package dry-run (mytheclipse-config) (push) Canceled after 0s Details CI / Cargo package dry-run (mytheclipse-crypto) (push) Canceled after 0s Details CI / Cargo package dry-run (mytheclipse-event) (push) Canceled after 0s Details CI / Cargo package dry-run (mytheclipse-storage) (push) Canceled after 0s Details Release / Semantic Release (push) Canceled after 0s Details Same E0432 class as mytheclipse-event: the crate-root doctests referenced feature-gated types that are absent in reduced-feature test builds flagged by the CI matrix. - mytheclipse-cache: example used MemoryCache (l1-memory) plus MultiLayerCache/CacheAside (cache-aside); the l1-moka and l2-redis builds (which don't enable cache-aside) failed the doctest. Gated the body behind all(l1-memory, cache-aside) with a no-op fallback. - mytheclipse-storage: example used LocalFileStorage (local feature); the gcs and s3 builds failed the doctest. Gated the body behind the local feature with a no-op fallback. Examples remain compile-checked & runnable under default features.	2026-08-28 22:49:39 +07:00
semantic-release-bot	52d9e1e93e	chore(release): 1.3.1 [skip ci] ## [1.3.1](https://github.com/asepharyana/mytheclipse/compare/v1.3.0...v1.3.1) (2026-08-28) ### Bug Fixes * ci: gate event crate doctest behind mem feature and apply rustfmt ([`1994115`](https://github.com/asepharyana/mytheclipse/commit/19941156b43ec58370d0d1369174ec84400e9bc9))	2026-08-28 15:41:53 +00:00
asepharyana	19941156b4	fix(ci): gate event crate doctest behind mem feature and apply rustfmt The crate-root doctest used InMemoryEventBus/TypedEventBus (gated behind the 'mem' feature), so `cargo test -p mytheclipse-event --no-default-features --features amqp\|nats` failed to compile the doctest (E0432). The example is now no_run with the mem-dependent imports inside a #[cfg(feature="mem")] main, so it compiles (and runs) when mem is on and degrades to an empty main when off. Also apply rustfmt to mytheclipse-config/dynamic.rs and mytheclipse-storage/{gcs,s3}.rs to satisfy cargo fmt --all --check.	2026-08-28 22:41:06 +07:00
semantic-release-bot	b2d3f32d83	chore(release): 1.3.0 [skip ci] # [1.3.0](https://github.com/asepharyana/mytheclipse/compare/v1.2.0...v1.3.0) (2026-08-28) ### Features * add corex-storage crate for unified storage abstraction ([`db4f277`](https://github.com/asepharyana/mytheclipse/commit/db4f277336d1e32cb6a2ddd86ac37ae9789fa4f8))	2026-08-28 15:30:52 +00:00
asepharyana	4d851c5a58	chore: rename corex-* crates to mytheclipse-* namespace CI / Rustfmt (push) Canceled after 0s Details CI / Clippy (push) Canceled after 0s Details CI / Test (workspace all features) (push) Canceled after 0s Details CI / Test (workspace default features) (push) Canceled after 0s Details CI / Test (mytheclipse / bg only) (push) Canceled after 0s Details CI / Test (mytheclipse / compute only) (push) Canceled after 0s Details CI / Test (mytheclipse / io only) (push) Canceled after 0s Details CI / Test (mytheclipse / lifecycle only) (push) Canceled after 0s Details CI / Test (mytheclipse / observability only) (push) Canceled after 0s Details CI / Test (mytheclipse / resiliency only) (push) Canceled after 0s Details CI / Test (mytheclipse / traffic only) (push) Canceled after 0s Details CI / Test (mytheclipse-cache / l2-redis) (push) Canceled after 0s Details CI / Test (mytheclipse-cache / l1-moka) (push) Canceled after 0s Details CI / Test (mytheclipse-cache / default) (push) Canceled after 0s Details CI / Test (mytheclipse-config / default) (push) Canceled after 0s Details CI / Test (mytheclipse-crypto / default) (push) Canceled after 0s Details CI / Test (mytheclipse-event / amqp) (push) Canceled after 0s Details CI / Test (mytheclipse-event / nats) (push) Canceled after 0s Details CI / Test (mytheclipse-event / default (mem)) (push) Canceled after 0s Details CI / Test (mytheclipse-storage / gcs) (push) Canceled after 0s Details CI / Test (mytheclipse-storage / s3) (push) Canceled after 0s Details CI / Test (mytheclipse-storage / default (local)) (push) Canceled after 0s Details CI / Run mytheclipse example (push) Canceled after 0s Details CI / Docs check (push) Canceled after 0s Details CI / Cargo package dry-run (mytheclipse) (push) Canceled after 0s Details CI / Cargo package dry-run (mytheclipse-cache) (push) Canceled after 0s Details CI / Cargo package dry-run (mytheclipse-config) (push) Canceled after 0s Details CI / Cargo package dry-run (mytheclipse-crypto) (push) Canceled after 0s Details CI / Cargo package dry-run (mytheclipse-event) (push) Canceled after 0s Details CI / Cargo package dry-run (mytheclipse-storage) (push) Canceled after 0s Details Release / Semantic Release (push) Canceled after 0s Details Rename all `corex-cache`, `corex-storage`, `corex-event`, `corex-config`, and `corex-crypto` crates to `mytheclipse-cache`, `mytheclipse-storage`, `mytheclipse-event`, `mytheclipse-config`, and `mytheclipse-crypto` respectively, aligning with the `mytheclipse` root crate naming convention. - Convert root `Cargo.toml` from a package manifest to a workspace manifest with explicit member paths - Update crate names in each `Cargo.toml` and docs.rs URLs - Update all import paths, module doc comments, and error/panic messages from `corex-` to `mytheclipse-` across source and README files - Update CI workflow and publish script to reference the new crate names<tool_call></think>chore: rename corex-* crates to mytheclipse-* namespace Rename all `corex-cache`, `corex-storage`, `corex-event`, `corex-config`, and `corex-crypto` crates to `mytheclipse-cache`, `mytheclipse-storage`, `mytheclipse-event`, `mytheclipse-config`, and `mytheclipse-crypto` respectively, aligning with the `mytheclipse` root crate naming convention. - Convert root `Cargo.toml` from a package manifest to a workspace manifest with explicit member paths - Update crate names in each `Cargo.toml` and docs.rs URLs - Update all import paths, module doc comments, and error/panic messages from `corex-` to `mytheclipse-` across source and README files - Update CI workflow and publish script to reference the new crate names	2026-08-28 22:29:49 +07:00
asepharyana	db4f277336	feat: add corex-storage crate for unified storage abstraction - Introduced corex-storage crate with support for local disk, S3-compatible, and Google Cloud Storage backends. - Implemented StorageDriver trait for various storage backends. - Added LocalFileStorage for local disk operations. - Added S3Storage for S3-compatible object storage with multipart upload support. - Added GcsStorage for Google Cloud Storage operations. - Included error handling for storage operations. - Added tests for each storage backend to ensure functionality. - Created README.md for documentation and usage examples. - Added Apache and MIT licenses for open-source compliance.	2026-08-28 22:24:18 +07:00