Skip to content
CAI
Software that uses CAICheck a score

gnieh/fs2-data

64.4

Adequate · 7 November 2026

23.2k

lines of production code

Scala

primary language

4

measurements over time

CAI band scale
CAI trend line
CAI lens gauges

What this system is

Features

Add CBOR diagnostic and debugging utilities

The CBOR module now includes a \Diagnostic\ object and associated package-level helpers (\diagnostic\, \debugDiagnostic\) that generate RFC 8949 diagnostic notation strings from CBOR item streams. This allows users to inspect and debug the structure and values of CBOR data during processing. The implementation also introduces \CborException\ for specific error handling, \HalfFloat\ for 16-bit float support, and \Tags\ for CBOR tag constants, laying the groundwork for more robust parsing and validation.

cbor/shared/src/main/scala/fs2/data/cbor · high confidence

Add CBOR to JSON transformation

Introduces a new \decodeItems\ pipe in the \fs2.data.cbor\ package that transforms a stream of CBOR items into a stream of JSON tokens. This feature implements the conversion rules specified in section 6.1 of RFC 8949, enabling users to convert CBOR data into JSON format. The implementation handles specific CBOR tags, including positive and negative big numbers (converted to decimal strings), and expected encoding tags for base64, base64url, and base16 data.

cbor-json/shared/src/main/scala/fs2/data/cbor · high confidence

Add Circe integration for JSON parsing and serialization

Introduces a new Circe backend for the fs2-data JSON library, providing implicit Builder, Tokenizer, Deserializer, and Serializer instances that bridge fs2-data's internal AST and token stream with io.circe.Json. This enables users to parse, serialize, and manipulate JSON using Circe's encoder/decoder ecosystem, including support for JSONPath queries and Merge Patch operations via the circe integration.

json/circe · high confidence

Add JSON data manipulation cookbook

Added a new cookbook demonstrating how to use fs2-data to build a jq-like CLI tool for reading, transforming, and writing JSON data. The entry includes a sample JSON file with user records and a JSON Lines file with nested data, along with documentation explaining the high-level approach and basic implementation using fs2-data-json operators like tokens, jq.Compiler, and render.prettyPrint.

site/cookbooks · high confidence

Add JSON to CBOR streaming encoder

Introduces a new \encodeItems\ pipe in the \fs2.data.json.cbor\ package that converts JSON tokens into CBOR items. This enables users to stream JSON data directly into CBOR format, handling integers, floats, booleans, nulls, strings, arrays, and objects. The encoder optimizes number representation by selecting the smallest exact CBOR type (e.g., 1, 2, 4, or 8-byte integers) and supports arbitrary-precision numbers via CBOR tags.

cbor-json/shared/src/main/scala/fs2/data/json · high confidence

Add JavaScript-specific Date serialization and deserialization for msgpack

The msgpack library for JavaScript now supports round-trip conversion of \js.Date\ objects. This change introduces platform-specific serializer and deserializer instances that map JavaScript Date objects to MessagePack timestamp formats (32-bit, 64-bit, and 96-bit), ensuring that date values are correctly preserved when serializing and deserializing data in a JavaScript environment.

msgpack/js · high confidence

Add Play JSON integration module

Introduces a new \json/play\ module that enables fs2-data to work with Play Framework's \JsValue\ type. This addition provides the necessary builder, tokenizer, serializer, and deserializer implementations to parse, construct, and transform JSON data using Play's native JSON library, along with a comprehensive suite of tests covering tokenization, path selection, merge patches, and exception handling.

json/play · high confidence

Add Scala 2 JSON selector string interpolator

Users can now use the \selector\ string interpolator in Scala 2 to create JSON selectors from string literals. This new capability, implemented in \SelectorInterpolator.scala\ and \package.scala\, leverages the \org.typelevel.literally\ library to parse and validate selector syntax at compile time, providing immediate feedback on invalid selector expressions.

json/interpolators/src/main/scala-2 · high confidence

Add Scala 3 JSON selector string interpolation

Users can now use the \selector\ string interpolation syntax in Scala 3 to construct JSON selectors at compile time. This new capability, implemented in \SelectorInterpolator\ and exposed via the \interpolators\ package, leverages Scala 3 macros to validate and parse selector strings, providing a more ergonomic way to define JSON paths compared to previous approaches.

json/interpolators/src/main/scala-3 · high confidence

Add Scala 3 jq string interpolator

Introduces a new \jq\ string interpolator for Scala 3, enabling compile-time validation and expression of JSON queries via \inline\ macros. This feature allows users to write concise, type-safe JSON path expressions directly in their Scala code, leveraging Scala 3's quote and splicing capabilities for static analysis of the query syntax.

json/src/main/scala-3/fs2/data/json/jq · high confidence

Add abstract Table type class for lookup operations

A new \Table\ type class has been introduced in the \fs2.data.matching\ package to provide a unified abstraction for lookup tables, which is useful for implementing finite state automata or transducers. This addition includes implicit instances for \Map\, \Function\, and \PartialFunction\, along with extension methods to simplify lookup syntax, enabling more flexible and composable pattern matching logic.

finite-state/shared/src/main/scala/fs2/data/matching · high confidence

Add compile-time XPath string interpolation

Added a new \xpath\ string interpolator in \fs2.data.xml.xpath.literals\ that parses XPath expressions at compile time. This allows users to write XPath queries directly as string literals (e.g., \xpath"/root/element"\) which are validated and converted into \XPath\ objects during compilation, providing immediate feedback on syntax errors and enabling static analysis of query structures.

xml/src/main/scala-2 · high confidence

Add documentation for the fs2-data-xml module

New documentation pages have been added to the site for the fs2-data-xml module, covering basic usage, XPath operators, XML renderers, and integration with the scala-xml library. The entry includes the navigation configuration for this section.

site/documentation/xml · high confidence

Add jq-like command-line example for JSON data manipulation

A new example application (\fs2-jq\) has been added to the \examples/jqlike\ directory, demonstrating a streaming implementation of a jq-like tool. Users can now run this CLI to parse JSON input (from strings or files), execute jq-style queries using \fs2.data.json.jq\, and output the results to stdout or a file, providing a concrete reference for integrating fs2-data's JSON query capabilities.

examples/jqlike · high confidence

Add low-level CBOR data item parser

Introduces a new low-level CBOR parser in the \fs2.data.cbor.low\ package, providing internal utilities to parse CBOR data items from byte streams. The implementation includes \ItemParser\ for handling chunked input and recursive parsing of integers, byte strings, and text strings, along with \MajorType\ constants defining CBOR major types and their corresponding byte markers. This enables users to access a lower-level API for CBOR serialization and validation.

cbor/shared/src/main/scala/fs2/data/cbor/low/internal · high confidence

Add platform-specific serialization and deserialization for Java Instant in msgpack high module

The \fs2.data.msgpack.high\ module now includes platform-specific instances for serializing and deserializing \java.time.Instant\. The new \PlatformSerializerInstances\ and \PlatformDeserializerInstances\ files handle conversion between \Instant\ and MessagePack timestamp formats (Timestamp32, Timestamp64, and Timestamp96), ensuring correct round-trip behavior for timestamp data in the high-level API.

msgpack/jvm-native · high confidence

Add scala-xml integration for parsing and building XML documents

Users can now parse and construct XML using the standard scala-xml library through new implicit DocumentBuilder and DocumentEventifier instances. The builder supports creating documents with version, encoding, standalone, and doctype metadata, as well as handling prolog and postlog content. The eventifier converts scala-xml Node and Document structures into fs2-data's XmlEvent stream, supporting comments, text, entity references, processing instructions, elements with prefixed and unprefixed attributes, and nested document structures.

xml/scala-xml/src/main · high confidence

Add scalafix rule to migrate JSON parsing syntax

A new scalafix rule named 'json-parse' has been added to automatically migrate code using the legacy \tokens()\ and \values()\ methods for JSON parsing to the new \ast.parse\ API. This change simplifies the codebase by replacing verbose method chains with a single, cleaner call, reducing boilerplate and improving readability for users of the fs2-data-json library.

scalafix/rules · high confidence

Added CSV benchmark dataset

A new CSV file containing 113 sample records has been added to the benchmark resources to support CSV parsing performance tests.

benchmarks/src/main/resources · high confidence

Added JSON Merge Patch support

The library now includes a new \mergepatch\ package that implements the JSON Merge Patch (RFC 7396) specification. This addition provides a \patch\ function that applies a patch document to a JSON stream, allowing users to replace, add, or delete keys and values within JSON objects using a streaming token-based approach.

json/diffson/src/main · high confidence

Added decoders and encoders for literal types and Scala 2 enumerations

The CSV module now supports decoding and encoding for Scala 2.13+ literal types (String, Char, Byte, Short, Int, Long, Float, Double, Boolean) via new LiteralCellDecoders and LiteralCellEncoders traits, allowing precise matching of specific constant values. Additionally, new EnumDecoders and EnumEncoders traits for Scala 2 enable seamless conversion of Enumeration values to and from CSV strings.

csv/shared/src/main/scala-2.13+ · high confidence

Added scalafix rules for CSV, JSON, and XML stream patterns

New scalafix rules have been added to automatically refactor stream processing code for CSV, JSON, and XML data formats. The \EmitsRows\ rule for CSV, \EmitsTokens\ for JSON, and \EmitsEvents\ for XML detect patterns where \Stream.emits\ is used in combination with \flatMap\ and \through\, and replace them with the more concise \rows\, \tokens\, or \events\ combinators respectively, while also handling type parameter inference for \String\ and \Char\ types.

scalafix/src · high confidence

Added site-wide search functionality to the navigation bar

The main navigation template now includes a search box integrated into the sidebar. This is implemented using the Pagefind UI library, which initializes a search interface within the new 'search' container on page load, allowing users to search the site content directly from the navigation area.

site/helium · high confidence

Compile-time XPath string interpolation

Users can now use the \xpath"..."\ string interpolator to define XPath expressions at compile time. This new feature in the \fs2.data.xml.xpath\ package leverages Scala 3 macros to parse and validate XPath literals during compilation, ensuring that syntax errors are caught early and allowing for more efficient runtime performance by avoiding repeated parsing.

xml/src/main/scala-3 · high confidence

Compile-time validated JSON Path literals

A new \jsonpath\ string interpolator is available in the \fs2.data.json\ package, allowing JSON paths to be defined as literals that are parsed and validated at compile time rather than at runtime. This change introduces a \JsonPathInterpolator\ backed by the \Literally\ library, which ensures that invalid JSON path syntax is caught during compilation, improving safety and reducing runtime errors for users constructing JSON queries.

json/src/main/scala-2/fs2/data/json/jsonpath, json/src/main/scala-3/fs2/data/json/jsonpath · high confidence

Introduce ESP core typeclasses and exception handling

Added foundational support for the ESP (Event Stream Processing) module by introducing the \Conversion\ typeclass for creating events from tags, the \Tag2Tag\ typeclass for transforming input tags to output tags, and the \ESPException\ class for error handling. These components provide the necessary abstractions for tag conversion and event generation within the finite-state shared library.

finite-state/shared/src/main/scala/fs2/data/esp · high confidence

Introduce Scala 3 semiauto CSV derivation with static headers

The CSV generic module now provides a new \semiauto\ object for Scala 3 that derives \RowDecoder\, \RowEncoder\, \CsvRowDecoder\, and \CsvRowEncoder\ using Shapeless 3. A key behavioral improvement is that \CsvRowDecoder\ and \CsvRowEncoder\ now implement the \StaticHeaders\ type class, exposing the column names at the type level for safer, header-aware CSV processing. Tuple decoding and encoding are also supported via the new \tuples\ object.

csv/generic/shared/src/main/scala-3/fs2/data/csv/generic · high confidence

Introduce XmlQueryPipe for DFA-based XML query processing

Added XmlQueryPipe, a new internal component that leverages a Deterministic Finite Automaton (PDFA) to process XML events. This pipe handles the matching of start and end tags and resolves attributes, serving as the core mechanism for executing XPath-like queries within the XML module.

xml/src/main/scala/fs2/data/xml/xpath/internals · high confidence

Introduce core pattern-matching type classes and exception

Added the \IsPattern\ type class for decomposing patterns into skeletons, the \IsTag\ type class for handling tag properties and range checks, and a \PatternException\ class for error reporting within the \fs2.data.pattern\ package.

finite-state/shared/src/main/scala/fs2/data/pattern · high confidence

Introduce high-level CBOR API for structured data processing

A new high-level API is now available in the \fs2.data.cbor.high\ package, providing structured \CborValue\ representations for easier CBOR data manipulation. This addition includes \values\ and \parseValues\ pipes to parse byte streams or low-level items into the high-level AST, and \toItems\ and \toBinary\ pipes to serialize \CborValue\ back to binary format. To maintain binary compatibility, a deprecated \HalfFloat\ object is included in this package, redirecting users to the main \fs2.data.cbor.HalfFloat\ implementation.

cbor/shared/src/main/scala/fs2/data/cbor/high · high confidence

Introduce high-level CBOR value parsing and serialization

Added internal \ValueParser\ and \ValueSerializer\ components to the high-level CBOR API, enabling the conversion between the library's abstract \CborValue\ representation and the underlying low-level \CborItem\ stream. This change allows users to parse CBOR data into a structured, high-level value tree and serialize those values back to CBOR bytes, supporting complex types such as indefinite-length arrays and maps, tagged values, and big integers.

cbor/shared/src/main/scala/fs2/data/cbor/high/internal · high confidence

Introduce high-level MessagePack serialization and deserialization API

The \fs2.data.msgpack.high\ module now provides a type-safe, high-level API for converting between Scala values and MessagePack streams. This includes \MsgpackSerializer\ and \MsgpackDeserializer\ type classes with built-in instances for standard types (Int, Long, BigInt, String, List, Map, etc.) and a generic \MsgpackValue\ AST. Users can leverage \fromItems\, \toItems\, \deserialize\, and \serialize\ pipes to stream data, with the high-level layer handling the mapping between language types and the underlying \MsgpackItem\ structure defined in the \low\ module.

msgpack/shared/src/main · high confidence

Introduce jq query compilation and piping infrastructure

Added the core Scala types for compiling and chaining jq queries within the fs2-data JSON library. The new \CompiledJq\ trait defines a stream pipe for executing compiled queries, while \PipedCompiledJq\ enables chaining multiple queries together, allowing users to compose complex jq expressions that process JSON token streams sequentially.

json/src/main/scala/fs2/data/json/jq · high confidence

Introduce low-level CBOR streaming API

A new low-level CBOR API is available in the \fs2.data.cbor.low\ package, providing a flat, stream-based representation that avoids building a full AST. This allows users to parse arbitrary-length and deep CBOR data efficiently, validate item streams, and serialize items back to binary bytes with optional validation.

cbor/shared/src/main/scala/fs2/data/cbor/low · high confidence

Introduce streaming XPath filtering API

The \fs2.data.xml.xpath\ package now provides a new \filter\ API for selecting XML elements via XPath queries in a streaming fashion. This includes \unsafeRaw\ for emitting matching element streams, \first\ for retrieving the initial match, \through\ for applying parallel transformations with configurable deterministic ordering, \dom\ for building element DOMs, \consume\ for side-effect processing, and \collect\ for aggregating results. The implementation compiles XPath expressions into a Deterministic Finite Automaton (DFA) to process \XmlEvent\ streams efficiently.

xml/src/main/scala/fs2/data/xml/xpath · high confidence

Introduce streaming pretty-printing framework for text rendering

The \fs2.data.text.render\ package now provides a new infrastructure for streaming text rendering, centered around \Renderable\ and \Renderer\ typeclasses that define how events are converted into document events. This includes utilities for handling alignment, indentation, and word splitting, along with a \pretty\ pipe that formats event streams into human-readable text with configurable width and indentation.

text/shared/src/main/scala/fs2/data/text/render · high confidence

Introduces Scala 2 generic derivation for CSV decoders and encoders

Adds a new generic derivation module for the CSV library on Scala 2, providing both automatic and semi-automatic derivation for Row, CsvRow, and Cell encoders and decoders. Users can now import \fs2.data.csv.generic.auto.\_\ to enable implicit derivation for case classes and HLists, or use \fs2.data.csv.generic.semiauto\ to explicitly derive instances. The implementation supports map-shaped CSV rows with optional column names via \CsvName\ annotations and handles default values for optional fields.

csv/generic/shared/src/main/scala-2 · high confidence

Introduces extensible XML tree building and eventification abstractions

The \fs2.data.xml.dom\ package now exposes core abstractions (\DocumentBuilder\, \ElementBuilder\, and \DocumentEventifier\) that allow users to define custom XML document and element structures, rather than being limited to a single built-in DOM. New companion pipes \documents\, \elements\, and \eventify\ utilize these builders to transform streams of XML events into user-defined tree nodes and back, enabling integration with external XML libraries like scala-xml while maintaining binary compatibility through deprecated legacy methods.

xml/src/main/scala/fs2/data/xml/dom · high confidence

Introduces predicate-based finite automata and tree query capabilities

This change adds new internal components to the \fs2.data.pfsa\ package to support automata with predicates and tree-based querying. It introduces the \Pred\ typeclass and \Candidate\ trait to define and select matching predicates, alongside \PDFA\ (Deterministic) and \PNFA\ (Nondeterministic) implementations that operate on these predicates, including a determinization algorithm in \PNFA\. Additionally, \TreeQueryPipe\ provides a pipe for executing recursive queries on tree-like structures (such as XPath or JsonPath) by leveraging the new \PDFA\ to match opening and closing tokens.

finite-state/shared/src/main/scala/fs2/data/pfsa · high confidence

New CBOR module and Msgpack benchmarks

This release introduces a new CBOR module with low-level item parsing and validation, alongside high-level model definitions. It also adds JMH benchmarks for the MessagePack serializer and deserializer to help monitor performance.

repository · high confidence

New JSON parsing, transformation, and rendering utilities

The \fs2.data.json\ package now exposes core stream processing capabilities, including \tokens\ for parsing character streams into JSON tokens, \filter\ for selecting values via selectors (though deprecated in favor of \jsonpath.filter\), and \transform\/\transformOpt\/\transformF\ for modifying selected JSON values. It also introduces \values\ and \tokenize\ for converting between tokens and JSON ASTs, \wrap\ and \unwrap\ objects for manipulating array/object boundaries (including \stripTopLevelArray\ with strict/non-strict modes), and a \render\ object for producing compact JSON representations from token streams.

json/src/main/scala/fs2/data/json · high confidence

New JSON selector DSL for type-safe path construction

The \fs2.data.json.selector\ package now exposes a DSL for building JSON selectors in a type-safe manner. Users can start with the \root\ entry point and chain methods like \index\, \indices\, \range\, \field\, and \fields\ to construct selectors. The DSL supports strict and lenient modes (via \?\) to control whether selection fails if the target is not an array or object, and optional and mandatory modes (via \!\) to control whether missing fields cause errors. Selectors are finalized by calling \compile\.

json/src/main/scala/fs2/data/json/selector · high confidence

New MFT builder DSL for declarative state machine construction

A new package object in the \fs2.data.mft\ module introduces a domain-specific language (DSL) for building Multi-Forest Transducers (MFT). This includes a \dsl\ entry point that accepts a builder function, helper methods for defining states (\state\) and input patterns (\any\, \aNode\, \anyNode\, \aLeaf\, \anyLeaf\, \epsilon\), and utility functions for constructing output transformations (\node\, \leaf\, \copy\, \default\, \applyToLeaf\). This allows users to define complex state machine logic using a more intuitive, tree-like syntax rather than manual builder instantiation.

finite-state/shared/src/main/scala/fs2/data/mft · high confidence

New streaming JSONPath filtering API

The \fs2.data.json.jsonpath\ package now provides a comprehensive set of streaming pipes for querying JSON data using JSONPath expressions. Users can select the first match, collect all matches into an AST, deserialize matches into specific types, or apply custom transformations to matching tokens. The API supports configurable limits on the number of matches and nesting depth, and allows control over whether results are emitted in deterministic (input) order or as soon as they are fully built.

json/src/main/scala/fs2/data/json/jsonpath · high confidence

New tree query compiler for MFT

Added a new \QueryCompiler\ in the \fs2.data.mft.query\ package that translates abstract tree queries (represented by nested for/let clauses and paths) into Macro Forest Transducers (MFT). This compiler implements the XQuery Streaming by Forest Transducers approach, allowing users to compile high-level query structures into optimized MFTs with configurable optimization passes.

finite-state/shared/src/main/scala/fs2/data/mft/query · high confidence

XML rendering and parsing enhancements

The XML module now supports pretty-printing output via new \render.prettyPrint\ and \collector.pretty\ methods, which indent nested tags and text for better readability. Parsing can now optionally preserve comments by passing \includeComments=true\ to the \events\ pipe, and a new \XmlException\ class provides structured error reporting for parsing failures.

xml/src/main/scala/fs2/data/xml · high confidence

Removals

Removal of legacy CSV parsing implementation

The legacy CSV parsing logic previously defined in \fs2.data.csv.package.scala\ has been removed. This deletion eliminates the old \fromBytes\ and \fromString\ pipes, which relied on line-based splitting and \ApplicativeError\, along with their associated internal helper methods for quote and field handling. Users relying on this specific package object API will need to migrate to the newly introduced CSV parsing abstractions.

csv · high confidence

Behavioural changes

6 commits (1 fix) modifying json/src/main/scala-2/fs2/data/json/jq

A change to existing behaviour in json/src/main/scala-2/fs2/data/json/jq — 6 commits (1 fix), 1 file: “Add jq parser interpolator”; “Finish parsing and compilationn”; “Fix behavior”; and 3 more.

json/src/main/scala-2/fs2/data/json/jq · medium confidence · unverified

Add internal utility for untagging TaggedJson tokens

A new internal helper function \untag\ has been added to the \fs2.data.json.tagged\ package. This utility converts \TaggedJson\ instances into standard \Token\ objects, handling specific tagged variants like \StartArrayElement\, \EndArrayElement\, and structural markers by returning \None\ where appropriate, while mapping raw tokens and object keys to their corresponding \Token\ representations.

json/src/main/scala/fs2/data/json/tagged · high confidence

Added Scala 2.12 compatibility shims for collection builders

A new package object in the Scala 2.12 source directory provides implicit extension methods (\addOne\) for \VectorBuilder\ and \ListBuffer\. This change ensures the library compiles and functions correctly on Scala 2.12 by supplying compatibility shims for collection operations that may differ or be missing in that specific version.

json/src/main/scala-2.12 · high confidence

Introduce new internal XML parsing and rendering architecture

The \fs2.data.xml.internals\ package has been replaced with a new set of components: \EventParser\ handles the low-level character stream parsing with support for XML 1.1 validation and comment preservation; \Normalizer\ merges adjacent text nodes and attributes; \ReferenceResolver\ expands character and entity references; and \Renderer\ provides configurable XML serialization with pretty-printing, indentation, and empty-tag collapsing. These changes alter the internal event flow and output formatting behavior of the XML library.

xml/src/main/scala/fs2/data/xml/internals · high confidence

Introduces an ESP-based JSON path compiler and execution engine

The library now uses a new internal execution strategy based on Event-Structure Parsing (ESP) for processing JSON path queries. This change replaces the previous implementation with \ESPJqCompiler\ to translate JSON path filters into regular expression matchers and \ESPCompiledJq\ to execute them via a stream pipeline. This new engine handles path components such as root, indices, slices, fields, and recursive descent, providing the underlying mechanism for JSON query evaluation.

json/src/main/scala/fs2/data/json/jq/internal · high confidence

Migrate documentation site to Laika

The documentation site has been migrated from the previous Ruby-based template system to Laika. This change introduces a new directory structure and navigation configuration (directory.conf) that explicitly orders the documentation pages for formats like CSV, JSON, XML, CBOR, and MsgPack, and replaces the old index content with updated introductory material explaining the library's streaming parsing architecture.

site/documentation · high confidence

Migration from Mill to sbt and introduction of Nix development shell

The project has switched its build system from Mill to sbt, removing the \build.sc\ file and adding \.sbtopts\ to configure JVM memory and read timeouts. To support this transition and provide an isolated development environment, a Nix flake (\flake.nix\ and \flake.lock\) has been added, allowing developers to use \nix develop\ for setup. Additionally, the code formatter configuration has been updated to scalafmt 3.11.5 with stricter literal casing rules and Scala 3 dialect support.

(repo-wide) · high confidence

New CharLikeChunks typeclass for efficient character stream iteration

A new \CharLikeChunks\ typeclass and its implementations have been added to the \fs2-data\ text module, enabling efficient iteration over characters in streams of \Char\, \String\, and various byte encodings (UTF-8, ASCII, ISO-8859-1, ISO-8859-15). This change introduces a specialized buffer mechanism that reduces copying overhead by sharing buffers between chunks, particularly benefiting UTF-8 byte streams which are now decoded into a reusable character buffer. The \package.scala\ file exposes implicit conversions for these encodings via \utf8\, \ascii\, \latin1\, and \latin9\ objects, allowing users to seamlessly treat byte streams as character streams. Deprecated implicit methods from previous versions are retained for binary compatibility but marked for removal in future releases.

text/shared/src/main/scala/fs2/data/text · high confidence

New streaming JSON documentation site

The JSON module documentation has been migrated to the Laika site generator and restructured into a dedicated section. The new site covers core parsing and AST building, serializers and deserializers, JSON renderers, and generating JSON streams. It also introduces dedicated pages for the experimental jq-like query language, JSONPath filtering, JSON Patch integration via diffson, and advanced transformation pipes using selectors and the selector DSL.

site/documentation/json · high confidence

Refactor CSV platform-specific encoder/decoder traits for JS/Native targets

The CSV module now includes platform-specific trait definitions for cell encoders and decoders in the js-native source directory. A new \PlatformCellDecoders\ trait defines the \javaUriDecoder\, while \PlatformCellEncoders\ (renamed from the previous \CsvException\ file) provides an empty trait structure, establishing the interface layer for JS/Native platform implementations.

csv/js-native · medium confidence

Refactor internal CSV parsing structures for Scala 3 compatibility

The internal implementation of CSV parsing has been refactored to support Scala 3. Specifically, the private \Headers\ and \ParseRowResult\ traits, which previously managed internal state for header initialization and row parsing results, have been removed. They have been replaced by new, empty \EnumDecoders\ and \EnumEncoders\ traits in the shared Scala 3 source directory, indicating a shift in how enum decoding and encoding logic is structured for the new compiler version.

csv/shared/src/main/scala-3 · medium confidence

Refactored CSV encoding and decoding into a unified Cell/Row type class hierarchy

The CSV library's internal architecture has been restructured to use a new \CellDecoder\/\CellEncoder\ type class for individual cell values and \RowDecoder\/\RowEncoder\ (along with their header-aware \CsvRowDecoder\/\CsvRowEncoder\ and generic \RowDecoderF\/\RowEncoderF\ variants) for entire rows. This change introduces \forColumns\ helper methods that allow users to decode or encode rows by specifying column headers or indices, replacing the previous ad-hoc parsing logic. The \CsvRow\ type now strictly validates that the number of values matches the number of headers, and the \EscapeMode\ trait provides explicit control over CSV escaping behavior (Auto, Always, Never).

csv/shared/src/main/scala/fs2/data/csv · high confidence

Refactored CSV internals into dedicated parser, writer, and row parser modules

The internal CSV processing logic has been reorganized into three new modules: CsvRowParser, RowParser, and RowWriter. CsvRowParser introduces an \attempt\ variant that allows consumers to handle parse errors on a per-row basis by emitting \Left\ elements instead of failing the stream, while also narrowing error types to \CsvException\. RowParser handles the low-level character stream parsing, including state management for quoted fields and line tracking. RowWriter manages column encoding, handling escaping and quoting based on the configured \EscapeMode\. This refactoring also migrates imports from \cats.implicits\ to \cats.syntax.all\ and updates collection usage to \Chunk.from\.

csv/shared/src/main/scala/fs2/data/csv/internals · high confidence

Refactored JSON parsing internals with configurable buffer capacities and new AST builder abstraction

The internal JSON parsing implementation has been restructured to improve performance and configurability. The \TokenParser\ now exposes system properties to configure buffer capacities for keys (\fs2.data.json.key-buffer-capacity\, default 64), numbers (\fs2.data.json.number-buffer-capacity\, default 16), and strings (\fs2.data.json.string-buffer-capacity\, default 128), allowing users to tune memory usage for specific workloads. Internally, the parser now uses a new \Builder\[Json\]\ trait and \ChunkAccumulator\ abstraction to construct AST values, replacing previous accumulation logic. This change includes a new \BuilderChunkAccumulator\ that builds JSON structures directly and a \LegacyTokenParser\ fallback for non-buffered character streams, ensuring compatibility while optimizing the primary parsing path.

json/src/main/scala/fs2/data/json/internal · high confidence

Refactored Scala 3 CSV derivation internals for compatibility and correctness

The internal derivation logic for Scala 3 has been rewritten to use Shapeless 3 and Scala 3 native features, introducing new internal components like CellValue, DerivedCellDecoder, DerivedCellEncoder, and OptCellDecoder. This change fixes handling of missing named columns, resolves binary compatibility issues for OptCellDecoder, and ensures that the Names given instance remains accessible to callers of deriveCsvRowDecoder/Encoder to prevent future breakage in Scala 3.7+.

csv/generic/shared/src/main/scala-3/fs2/data/csv/generic/internal · high confidence

Restored URL encoding and decoding support on the JVM

The CSV library now supports encoding and decoding \java.net.URL\ values on the JVM platform. This change introduces platform-specific encoder and decoder traits that provide \CellEncoder\[URL\]\ and \CellDecoder\[URL\]\ instances, restoring functionality that was previously unavailable or removed, while noting that URL support remains excluded from the Scala.js target.

csv/jvm · high confidence

Site migrated to Laika documentation generator

The project website has been rebuilt using the Laika static site generator, replacing the previous setup. This change introduces a new site structure with a custom navigation order defined in directory.conf, a CNAME record pointing to fs2-data.gnieh.org, and an updated home page that lists all available fs2-data modules (JSON, XML, CSV, CBOR, MessagePack) along with their respective ecosystem integrations and current adopters.

site · high confidence

Stubbed literal cell decoders and encoders for Scala 2.12

The library now provides empty trait stubs for \LiteralCellDecoders\ and \LiteralCellEncoders\ in the Scala 2.12 source directory. Since literal types are not supported in Scala 2.12, these traits are intentionally left empty to satisfy the shared API structure without enabling literal-based CSV cell conversion for this version.

csv/shared/src/main/scala-2.12- · high confidence

Test coverage

Add JMH benchmarks for CSV, JSON, MessagePack, XML, and XPath operations; Added CSV parsing test fixtures for edge cases; Added JSON test suite resources for edge-case parsing; Added Sun XML test suite resources for validation testing; Added comprehensive CBOR test suite; Added comprehensive test coverage for CBOR-JSON conversion; Added comprehensive test suite for CSV parsing, encoding, and decoding; Added comprehensive test suite for the new MessagePack serialization and parsing implementation; Added test coverage for ESP transformation capabilities; Added test coverage for generic CSV derivation; Added test for JSON selector literal parsing; Added test input for the json-parse scalafix rule; Added test utilities for MiniXML and MiniXPath; Added tests for CSV generic auto-derivation and HList encoding/decoding; Added tests for JSON Merge Patch operations; Added tests for MFT article-to-HTML transformation and pattern matching compiler; Added tests for MFT query compilation and execution; Added tests for Scala 3 tuple derivation and inaccessible name regression; Added tests for literal decoders and encoders; Added tests for pattern matching with and without guards; Added tests for regular language operations; Added tests for scala-xml integration; Added tests for the new \parse\ migration rule.

Dependencies

Upgrade to fs2 3.14.0 and Scala 3.3.8

The build configuration has been updated to use fs2 3.14.0 and Scala 3.3.8 (alongside Scala 2.12.21 and 2.13.18). This upgrade brings the project to the latest stable versions of its core streaming library and the Scala compiler, ensuring compatibility with recent language features and runtime improvements. Other dependencies like circe (0.14.16), play-json (3.0.6), and weaver (0.13.0) have also been updated to their latest versions as defined in the build.sbt.

(dependencies) · high confidence

Housekeeping

Migrate CSV module documentation to Laika

The documentation for the \fs2-data-csv\ and \fs2-data-csv-generic\ modules has been migrated to the Laika documentation framework. This update introduces new \index.md\ and \generic.md\ pages that detail the high-level and low-level APIs, including usage examples for decoding and encoding CSV data with case classes, handling headers, and managing errors via the \lenient\ package. A \directory.conf\ file has also been added to define the navigation order for these new documentation pages.

site/documentation/csv · high confidence

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

How this codebase got here

Score

  • CAI 55 → 64 (+9.6)
  • Rubric changed (rubric-2026.10.5 → rubric-2026.11.2) — scores are not directly comparable.

Lenses

  • Code Health 67 → 67 (+0.0)
  • Architecture 73 → 73 (+0.0)
  • Maturity 41 → 62 (+20.7)
  • Readiness 61 → 61 (+0.5)
  • Security 83 → 74 (-8.5)
  • Performance 76 → 90 (+13.7)

Resolved (5)

  • Off-boarding risk: anonymized user #1
  • Off-boarding risk: anonymized user #2
  • Outdated: com.beachape:enumeratum_2.13
  • Outdated: io.circe:circe-generic-extras_2.13
  • Outdated: org.gnieh:fs2-data-json-circe_2.13

New (4)

  • Dependency hygiene PARTLY measured — sbt declarations read, dependency currency not (Maven Central unreachable)
  • Documentation: no build, run or usage example (README.md)
  • Off-boarding risk: anonymized user #1
  • Off-boarding risk: anonymized user #2

Changes since last survey

  • 9 commits — 9 feature/other, 0 fixes

By area

  • (repo) — 7 commits
  • (root) — 1 commit
  • project/build.properties — 1 commit

Notable commits

  • change: Merge branch 'main' into update/scala-java-time-2.8.0
  • change: Merge branch 'main' into update/scala-xml-2.5.0
  • change: Merge pull request #803 from scala-steward/update/scala-library-3.9.0
  • change: Merge pull request #805 from scala-steward/update/scala-xml-2.5.0
  • change: Merge pull request #817 from scala-steward/update/scala-java-time-2.8.0
  • change: Merge pull request #824 from scala-steward/update/scala-java-time-2.9.0
  • change: Merge pull request #825 from scala-steward/update/sbt-1.13.1
  • change: Update sbt, scripted-plugin to 1.13.1
  • change: Update scala-java-time, ... to 2.9.0

Architecture

  • Unchanged — 0 containers · 1 contexts · 0 edges

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

Survey your own repository

gnieh/fs2-data 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.

About this page

  • The score is its most recent published measurement, taken on 7 November 2026 at a pinned commit. It is not a live figure and does not change until the project is measured again.
  • Measured at commit a838d4752199727e48906e637ffe5f9d8dd138cb — the exact code this score is about.
  • Scored under rubric-2026.11.2 — the same rubric and the same method as every other entry in this index.
  • Measured by Canine Code Analyzer (cca.canine.dev) using cca measure-2026.11.3+preprod-c34be012586e.