yaes-io/yaes

YAES is a structured concurrency and effect system library for Scala 3 that provides primitives for error handling, resource management, and asynchronous data streaming. It includes a comprehensive HTTP framework featuring a type-safe server DSL with named-tuple routing and an effect-based client with typed error handling. The ecosystem extends to interoperability with Cats, JSON libraries like Circe and jsoniter, and standard logging via SLF4J, all supported by dedicated testing utilities and automated migration tools.

The website now includes a new documentation site scaffolded with Astro and Starlight. This adds the necessary configuration files (astro.config.mjs, tsconfig.json, .gitignore) and a README to support the new documentation structure, including sidebar navigation for core concepts, advanced effects, HTTP modules, integrations, and testing utilities.

website · high confidence

The website now includes a custom SVG favicon that adapts to dark mode preferences and a CNAME file pointing to www.yaes.io, establishing the site's visual identity and domain configuration.

website/public · high confidence

The yaes-http module now includes a new jsoniter-scala integration that provides automatic BodyEncoder and BodyDecoder instances for any type with a JsonValueCodec in scope. Users can import io.yaes.http.jsoniter.given to enable seamless JSON request/response handling, where responses are encoded to compact JSON with application/json content type and requests are decoded with parse errors mapped to DecodingError.ParseError. The integration supports nested case classes and requires jsoniter-scala-macros for compile-time codec derivation.

yaes-http/jsoniter · high confidence

The yaes-http module now includes the foundational components for HTTP request handling and response writing. In the core module, new typeclasses \BodyDecoder\ and \BodyEncoder\ provide built-in support for decoding and encoding primitive types (String, Int, Long, Double, Boolean) with appropriate content types, alongside a \DecodingError\ type for typed error handling. The server parsing module introduces \HttpParser\ to parse HTTP/1.x requests (including request lines, headers, and bodies with size limits) and \HttpWriter\ to serialize HTTP responses to output streams. A comprehensive \HttpParseError\ sealed trait defines specific error conditions such as malformed request lines, unsupported methods, and payload size violations, each mapping to standard HTTP status codes.

yaes-http/core, yaes-http/server/src/main/scala/io/yaes/http/server/parsing · high confidence

The website now includes the foundational configuration and styling for a new Starlight-based documentation site. This change introduces the content collection setup in \content.config.ts\ to define the documentation schema and loaders, and adds a comprehensive \custom.css\ file that implements a Catppuccin Mocha/Latte theme, custom typography (Inter and JetBrains Mono), and specific layout styles for the homepage hero and learning path steps.

website/src, website/src/styles · high confidence

This change establishes the foundational structure for the λÆS (Yet Another Effect System) library. It introduces core documentation files (README, ARCHITECTURE, CLAUDE, CONVENTIONS, FINDINGS, TESTS) that define the library's effect composition model, module structure (yaes-core, yaes-data, yaes-cats, etc.), and coding standards. It also adds build configuration files including \.scalafmt.conf\ (v3.11.1), \.jvmopts\ (enabling preview features), \.gitignore\, and \renovate.json\ for dependency management. The README specifies the library's experimental status, its requirement for Java 25, and lists the available modules and effects.

(repo-wide) · high confidence

This change introduces the core \yaes\ library, providing a structured concurrency and effect-system framework for Scala. It includes a \Raise\ effect for error handling, a \Resource\ effect for automatic cleanup, and a \Clock\ effect for time management. The library also provides effects for console \Input\/\Output\, \Log\ging, \Random\ number generation, and \Reader\-style environment access. Structured concurrency is implemented via \Async\, leveraging Java's \StructuredTaskScope\ to manage fibers and scopes, and includes a \CircuitBreaker\ for protecting downstream calls and a \Retry\ mechanism with configurable schedules.

yaes-core/src/main · high confidence

The yaes-cats module now provides first-class interoperability with the Cats ecosystem. Users can convert YAES Raise computations to Cats Validated types (Validated, ValidatedNec, ValidatedNel) and vice versa, and integrate YAES Sync programs with Cats Effect IO using bidirectional conversion utilities. The module also adds polymorphic error accumulation support for Cats' NonEmptyList and NonEmptyChain types, along with syntax extensions for fluent error combining on collections.

yaes-cats/src · high confidence

The new \yaes-http-circe\ module provides \BodyEncoder\ and \BodyDecoder\ instances that automatically serialize and deserialize JSON bodies using Circe. By importing \io.yaes.http.circe.given\, users can handle typed request and response bodies seamlessly; the encoder outputs compact JSON with an \application/json\ content type, while the decoder maps Circe parse failures to \DecodingError.ParseError\ and validation failures to \DecodingError.ValidationErrors\. This allows routes to use standard Scala case classes with Circe's automatic or semi-automatic derivation for robust JSON handling.

yaes-http/circe · high confidence

Adds a new Sandcastle subsystem that automates issue resolution using an AI agent. The setup includes a Dockerfile provisioning a sandbox with JDK 25, sbt, and Claude Code, along with TypeScript orchestration logic that runs an implement-then-review loop. The implementer agent processes open issues sequentially, while a reviewer agent inspects and refines the resulting code changes on dedicated branches.

.sandcastle · high confidence

The yaes-data module now provides a new asynchronous data-streaming API built on a custom Channel implementation and a Flow abstraction. Users can create cold, asynchronous streams via Flow (with operators like collect, transform, buffer, merge, and file/InputStream sources) and communicate between fibers using Channel (supporting bounded, unbounded, and rendezvous buffering with overflow strategies). Additionally, Flows can be bridged to standard Java Reactive Streams Publishers via FlowPublisher, enabling interoperability with existing Reactive Streams libraries while respecting backpressure.

yaes-data/src · high confidence

The yaes-http/client module now provides a new effect-based HTTP client built on Java's HttpClient, integrating with the yaes effect system for structured error handling and lifecycle management. Transport errors (e.g., connection refused, timeouts) are raised as typed \ConnectionError\ values, while HTTP-level errors (non-2xx status codes) are raised as specific \HttpError\ subtypes (e.g., \NotFound\, \InternalServerError\) only when decoding responses via \HttpResponse.as\. The client supports configurable timeouts, redirect policies, and HTTP versions (1.1/2), and includes a fluent builder API for requests. Additionally, it features a compile-time validated \uri\ string interpolator and a \/\ path segment operator for ergonomic, type-safe URI construction with automatic URL encoding of path parameters.

yaes-http/client · high confidence

The yaes-slf4j module introduces a new handler that allows applications to route the existing \Log\ effect through the SLF4J ecosystem. By switching from \Log.run\ to \Slf4jLog.run\, users can leverage standard SLF4J backends (such as Logback or Log4j2) to control log formatting, output destinations, and level filtering via their existing configuration files. The implementation maps the framework's \fatal\ level to SLF4J's \error\ level and respects backend-specific guards to avoid evaluating by-name message arguments when logging is disabled.

yaes-slf4j/src · high confidence

A new Scalafix rule, MigrateV021ToV022, is now available to automatically update YAES source code from the 0.21.0 package layout (in.rcard.yaes) to the 0.22.0 layout (io.yaes). The rule rewrites package declarations, all import styles (named, braced, wildcard, and sub-packages), fully-qualified type references, and string literals containing the old prefix. It also handles inline comments, block comments, and Scaladoc (including code examples) to ensure documentation and string-based references are updated. The migration is idempotent, meaning running it on already-migrated code has no effect.

yaes-migration/rules · high confidence

The server now provides a new, type-safe routing DSL that encodes path and query parameters as named tuples, allowing handlers to access parameters by name (e.g., \path.userId\) with compile-time verification. This change replaces the previous per-arity method overloads with a unified approach that collapses route definitions into general and ergonomic forms, simplifying the API for both parameterized and simple routes.

yaes-http/server/src/main/scala/io/yaes/http/server · high confidence

Route handlers now receive path and query parameters as Scala named tuples rather than positional arguments. This allows handlers to access parameters by name (e.g., \path.id\, \query.limit\) regardless of declaration order, making the API order-independent and self-documenting. The change introduces new type-level utilities for combining parameter tuples and runtime structures for parsing and error handling, including \PathParamParser\, \QueryParamParser\, and specific error types for missing or invalid values.

yaes-http/server/src/main/scala/io/yaes/http/server/params · high confidence

The routing layer now uses type-safe path patterns that encode expected path and query parameter structures at compile time. When a request matches a route, parameters are extracted and passed to handlers as named tuples, ensuring type correctness. Invalid or missing parameters automatically result in 400 Bad Request responses with descriptive error messages.

yaes-http/server/src/main/scala/io/yaes/http/server/routing · high confidence

Added comprehensive test coverage for Async, CircuitBreaker, and core effects; Added comprehensive test suite for HTTP server components; Added tests to verify Unscoped capability encapsulation; New ScalaTest mixins and stubs for testing effects and HTTP clients.

The project now includes a comprehensive \build.sbt\ file defining the multi-module structure (including \yaes-core\, \yaes-data\, \yaes-cats\, \yaes-slf4j\, \yaes-http\, \yaes-test\, and \yaes-migration\) and sets the Scala version to 3.8.3 with a target of JDK 25. Additionally, a Starlight documentation site scaffold has been added, introducing dependencies for Astro 6.0.1, @astrojs/starlight 0.38.1, and sharp 0.34.2.

(dependencies) · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• First survey — no prior run to compare against. CAI 71.

• Code Health 99
• Architecture 85
• Maturity 67
• Readiness 68
• Security 77

• 300 commits — 222 feature/other, 78 fixes

• yaes-core/src — 73 commits
• (repo) — 57 commits
• yaes-http/server — 30 commits
• website/src — 29 commits
• (root) — 27 commits
• yaes-http/client — 19 commits
• yaes-http/circe — 9 commits
• yaes-test/core — 8 commits
• yaes-http/core — 7 commits
• yaes-http/jsoniter — 6 commits
• yaes-migration/rules — 6 commits
• yaes-test/http — 6 commits
• yaes-data/src — 5 commits
• yaes-cats/src — 4 commits
• yaes-core-test/scalatest — 4 commits
• website/astro.config.mjs — 3 commits
• project/build.properties — 2 commits
• .sandcastle/Dockerfile — 1 commit
• docs/agents — 1 commit
• docs/superpowers — 1 commit

• fix: Merge pull request #268 from rcardin/issue-253-raise-catching-fix
• fix: Merge pull request #277 from rcardin/274-retry-bypass-bug-when-block-captures-outer-raisee-f-via-contravariance
• fix: Merge pull request #319 from yaes-io/fix/async-run-scope-restore
• fix: Potential fix for pull request finding
• fix: Potential fix for pull request finding
• fix: Potential fix for pull request finding
• fix: Potential fix for pull request finding
• fix: Potential fix for pull request finding
• fix: Potential fix for pull request finding
• fix: Potential fix for pull request finding
• fix: Potential fix for pull request finding
• fix: Potential fix for pull request finding
• fix: Potential fix for pull request finding
• fix: Potential fix for pull request finding
• fix: Potential fix for pull request finding
• fix: Potential fix for pull request finding
• fix: Potential fix for pull request finding
• fix: Potential fix for pull request finding
• fix: Potential fix for pull request finding
• fix: Potential fix for pull request finding
• …and 280 more

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

yaes-io/yaes was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.