nfdi4plants/ARCtrl

ARCtrl is a cross-platform library for managing Annotated Research Contexts, enabling the creation, manipulation, and serialization of experimental metadata across .NET, JavaScript, and Python. It provides comprehensive support for ISA-Tab and RO-Crate standards, allowing users to parse and export investigations, studies, assays, and runs via spreadsheets, JSON, and YAML. The system also handles Common Workflow Language (CWL) definitions, offering tools to model, resolve, and visualize workflow execution graphs.

56 changes.

The project was restructured and renamed to ARCtrl, establishing a unified multi-language platform supporting .NET, JavaScript, and Python via a FAKE-based build system. Core domain models for ARC, file systems, and ISA-Tab metadata were rewritten to ensure cross-platform consistency and ISA-JSON compliance. Comprehensive test suites and serialization layers were added to validate the new architecture across all supported runtimes.

15 changes.

This period focused on implementing core RO-Crate serialization and conversion capabilities, including JSON-LD support and the mapping of experimental units like Assays and Studies. It also introduced the WorkflowGraph library to model, analyze, and visualize Common Workflow Language (CWL) structures as directed graphs with Mermaid output. Comprehensive test coverage was added for these new features, alongside updates to Datamap handling and dependency references.

New F\# extension modules have been added to the \src/ARCtrl/JsonIO/Process\ directory to provide JSON serialization capabilities for Process-related domain entities. These files implement \fromISAJsonString\ and \toISAJsonString\ methods for types including Component, Factor, FactorValue, Material, MaterialAttribute, MaterialAttributeValue, MaterialType, Process, ProcessInput, ProcessOutput, ProcessParameterValue, ProcessSequence, Protocol, ProtocolParameter, Sample, Source, and ScalarValue. Additionally, several types (Component, Material, MaterialAttributeValue, Process, ProcessOutput, ProcessParameterValue, ProcessSequence, Protocol, Sample, Source) now support ROCrate JSON serialization via \fromROCrateJsonString\ and \toROCrateJsonString\ methods. The \StudyMaterials\ module provides a write-only ISA JSON encoder for aggregating sources, samples, and materials.

src/ARCtrl/JsonIO/Process · high confidence

Introduces new modules (LDContext, LDGraph, LDNode, LDRef, LDValue) to handle encoding and decoding of JSON-LD structures within ROCrate. This enables the library to correctly parse and generate complex JSON-LD graphs, including support for null values, boolean properties, and context proxies for versions 1.1 and 1.2.

src/Json/ROCrate · high confidence

Users can now serialize and deserialize ValidationPackage and ValidationPackagesConfig models to and from YAML strings. This new capability in the ARCtrl.Yaml module uses the YAMLicious library to provide encoder/decoder logic that mirrors the existing JSON implementation, allowing configuration data to be stored in YAML format.

src/Yaml · high confidence

New files in the ArcTable JSON IO module introduce compressed JSON serialization capabilities for ArcTable and Template objects. This includes dedicated encoder/decoder logic that utilizes shared string, ontology annotation, and cell tables to reduce payload size, along with helper modules for compression and specific type extensions (CompositeCell, CompositeHeader, IOType) to support the broader table structure.

src/ARCtrl/JsonIO/Table · high confidence

The WebRequest module now supports Fable compilation to JavaScript and Python, in addition to the existing .NET and browser targets. For JavaScript, it detects Node.js environments to use \isomorphic-fetch\ for downloading files, while falling back to standard browser HTTP for other JS contexts. For Python, it wraps the \requests\ library to provide equivalent GET, POST, PUT, DELETE, HEAD, and OPTIONS capabilities. This allows the application to perform web requests consistently across all supported Fable compilation targets.

src/ARCtrl/WebRequest · high confidence

New SVG assets have been added to the logos/creation directory, including ARC.svg, HandCleaned.svg, HandNoString.svg, and HandWithString.svg, alongside an update to image.svg. These changes introduce new visual assets for the creation workflow, specifically adding the ARC logo and refined versions of the Hand logo.

logos · high confidence

The \src/Contract\ module now provides contract definitions for managing ISA Investigation, Study, Assay, and Run entities, as well as Workflows, Datamaps, Licenses, and ValidationPackagesConfig. Users can now create, update, and delete contracts for these resources, with support for CWL descriptions in Runs and Workflows, and YAML-based configuration for ValidationPackages.

src/Contract · high confidence

The \src/ARCtrl\ module now provides a unified \ARC\ class that manages the in-memory representation of an Annotated Research Context and its synchronization with the file system via a contract system. Users can serialize and deserialize ARC objects to and from RO-Crate JSON format using the new \ROCrateIO\ module, which handles metadata, licenses, and entity conversion. The library also introduces cross-platform asynchronous I/O support via \CrossAsync\, enabling consistent async operations across JavaScript, Python, and .NET backends, and exposes controllers for JSON, XLSX, and YAML parsing to facilitate data import and export.

src/ARCtrl · high confidence

Added the ARCtrl.Contract module (src/Contract/Contract.fs) which defines the core data structures for describing file operations within the application. This includes the DTOType enum for identifying file formats (such as ISA spreadsheets, JSON, and CLI tools), the DTO union type for holding file content, and the Contract record type which specifies the operation (CREATE, UPDATE, DELETE, READ, EXECUTE, RENAME), target path, and associated data. Static factory methods are provided to construct these contracts, enabling a structured way to communicate file I/O and tool execution intents.

ARCtrl.Contract · high confidence

The CWL module now exposes a unified CWLProcessingUnit discriminated union that groups CommandLineTool, Workflow, ExpressionTool, and Operation descriptions, providing consistent static accessors for inputs, outputs, requirements, hints, and intent across all variants. Supporting this are new type definitions in CWLTypes.fs (including FileInstance, DirectoryInstance, and SchemaSaladString), dedicated description models for expression tools and operations, and helper modules for dynamic object property handling, hashing, and YAML encoding that ensure correct serialization and equality semantics for CWL objects.

src/CWL · high confidence

The ARCtrl.CWL module now includes explicit type definitions for CWL workflow steps, specifically the StepInput and StepOutputParameter models. These types expose fields required by the Common Workflow Language specification, such as source connections, default values, link merge methods, pick value strategies, and scatter methods, enabling the system to accurately represent and process complex workflow step configurations.

ARCtrl.CWL · high confidence

Added new modules for handling Datamap data structures, including JSON serialization/deserialization in src/Json/Datamap and spreadsheet table parsing/writing in src/Spreadsheet/DatamapTable. Users can now read and write Datamap tables from ISA-Tab style spreadsheets, with automatic handling of data contexts, ontology annotations, and custom comments.

src/Json/Datamap, src/Spreadsheet/DatamapTable · high confidence

The new src/FileSystem module provides core utilities for managing ARC file structures. It includes the ArcPathHelper for cross-platform path normalization (handling separators, drive prefixes, and resolving relative paths), a FileSystemTree type for representing and manipulating directory hierarchies, and predefined default content for .gitignore (macOS, Windows, Linux rules), .gitattributes (LFS for dataset folders), and license files.

src/FileSystem · high confidence

Added the core data models for validation packages: \ValidationPackage\ (holding name and version) and \ValidationPackagesConfig\ (holding a collection of packages and an optional ARC specification). These types provide mutable properties, structural equality checks, and Python-compatible string representations to support validation configuration handling.

src/ValidationPackages · high confidence

The new \src/WorkflowGraph\ module provides a deterministic, queryable graph model derived from Common Workflow Language (CWL) processing units. It introduces adapters to convert ARC domain objects (\ArcWorkflow\, \ArcRun\, \ArcInvestigation\) into graph structures, handling CWL description lookups and run path resolution automatically. The library exposes a public API for building these graphs, querying nodes and edges (such as data flow, containment, and port connections), and visualizing the results as Mermaid diagrams or Markdown. This enables users to inspect the structure of workflows and runs, including nested references and unresolved dependencies, through a standardized graph representation.

src/WorkflowGraph · high confidence

The ARCtrl.FileSystem module now exposes the foundational data structures for managing file system state. Users can create and manipulate a FileSystem object, which encapsulates a file tree and a history of commits. The API supports adding individual files, constructing a file system from a list of file paths, merging two file systems (unioning their trees and histories), and creating deep copies of the state.

ARCtrl.FileSystem · high confidence

The ARCtrl.WorkflowGraph library now provides the foundational types and builder logic for representing CWL workflows as directed graphs, along with a Siren-based renderer that outputs Mermaid flowcharts. Users can now construct workflow graphs from CWL processing units using configurable build options (such as expanding nested workflows or enforcing strict reference resolution) and visualize the resulting structure with distinct node shapes and colors for workflows, tools, expression tools, and operations.

ARCtrl.WorkflowGraph · high confidence

The \src/Json/Process\ module now provides comprehensive JSON serialization and deserialization logic for the entire Process domain model, supporting both ISA-JSON and RO-Crate formats. New encoder and decoder modules have been added for \Process\, \Protocol\, \Sample\, \Source\, \Material\, \Component\, \Factor\, \FactorValue\, \MaterialAttribute\, \MaterialAttributeValue\, \ProcessInput\, \ProcessOutput\, \ProcessParameterValue\, and \ProtocolParameter\. This enables the application to correctly read and write complex experimental workflows, including inputs, outputs, parameters, and material characteristics, in both standardized formats.

src/Json/Process · high confidence

The \src/Spreadsheet\ module now provides full read/write support for ISA-compliant experimental metadata via new \ArcAssay\, \ArcRun\, \ArcStudy\, and \ArcWorkflow\ parsers. Users can now import and export assay, run, study, and workflow metadata from Excel workbooks, with each entity mapped to its own worksheet (e.g., \isa\_assay\, \isa\_run\, \isa\_study\, \isa\_workflow\). The parsers automatically detect and include associated annotation tables and datamaps within the workbook, ensuring that complex experimental designs are preserved during serialization. This replaces the previous ad-hoc handling with a structured, type-safe approach for managing spreadsheet-based metadata.

src/Spreadsheet · high confidence

The \src/ARCtrl/JsonIO\ module now provides a comprehensive set of JSON serialization and deserialization extensions for ArcCtrl domain types, including \ArcAssay\, \ArcInvestigation\, \ArcRun\, \ArcStudy\, \ArcWorkflow\, \Comment\, \Data\, \DataFile\, \Datamap\, \LDNode\, \LDGraph\, \OntologyAnnotation\, \OntologySourceReference\, \Person\, and \Publication\. These extensions enable users to convert domain objects to and from standard JSON strings, compressed JSON strings, ROCrate (JSON-LD) format, and ISA-Tab JSON format. The implementation uses conditional compilation to support multiple target platforms (Python, JavaScript/TypeScript, and .NET) via the Thoth.Json library.

src/ARCtrl/JsonIO · high confidence

The \src/Json\ directory now contains a comprehensive set of new F\# modules (including Assay, Comment, Data, Investigation, OntologyAnnotation, Person, and others) that implement JSON encoding and decoding for the core ArcCtrl domain models. This new layer supports three distinct output formats: the native ArcCtrl format, RO-Crate (with specific handling for identifiers, contexts, and property mappings), and ISA-JSON (including ID table management for cross-referencing). It also introduces compressed JSON encoding strategies using string and ontology annotation tables to reduce payload size, alongside helper modules for custom decoding logic (such as URI validation and datetime handling for Fable/Python targets) and encoding utilities.

src/Json · high confidence

The \src/ARCtrl/Conversion\ module now includes new conversion files (Assay.fs, Study.fs, Investigation.fs, etc.) that implement the mapping between internal ARC data models and the RO-Crate format. This change adds the capability to compose and decompose Assays, Studies, and Investigations, including handling of data files, fragment descriptors, and person/author information, effectively enabling the export and import of these core experimental units as part of an RO-Crate.

src/ARCtrl/Conversion · high confidence

The ARCtrl.Spreadsheet module now includes new F\# source files to parse and write ISA-Tab style metadata sheets. ArcInvestigation.fs handles the 'isa\_investigation' sheet, mapping fields like identifier, title, and submission date, while Study.fs manages 'STUDY' sheets including design descriptors and assays. Template.fs introduces support for reading and writing 'TEMPLATE' sheets, including a migration path that maps deprecated column headers (e.g., 'Authors ORCID' to 'Comment\[...\]') to the new schema. These changes rely on a new SparseTable.fs utility for handling sparse row/column data structures within the spreadsheet metadata.

ARCtrl.Spreadsheet · high confidence

Added new F\# modules in src/Spreadsheet/Metadata to parse and serialize ISATab-style spreadsheet data for ArcAssay, ArcRun, ArcWorkflow, Person, Protocol, and Publication entities. These modules handle mapping spreadsheet columns to domain objects, including ontology annotations, comments, and aggregated string fields, enabling the application to read and write structured metadata from spreadsheet files.

src/Spreadsheet/Metadata · high confidence

The project has been restructured and renamed from ARC to ARCtrl, introducing a unified solution that supports .NET, JavaScript, and Python. The solution files (ARCtrl.sln, ARCtrl.Py.sln) now define a comprehensive set of projects including core libraries (ARCtrl.Core, ARCtrl.Contract, ARCtrl.Json, ARCtrl.Spreadsheet, ARCtrl.FileSystem, ARCtrl.CWL, ARCtrl.Yaml, ARCtrl.ROCrate, ARCtrl.WorkflowGraph) and their corresponding test suites. The repository also includes new configuration files such as .editorconfig, .gitignore, and .zenodo.json for metadata and contributors, alongside updated documentation in README.md and RELEASE\_NOTES.md.

(repo-wide) · high confidence

The project now uses a new FAKE (F\# Make) build script located in the \build/\ directory to manage the build, test, and release lifecycle for .NET, JavaScript, and Python components. This system introduces tasks for transpiling F\# code to JavaScript and Python via Fable, running tests with Vitest (JS) and pytest (Python), and packaging artifacts for NuGet, npm, and PyPI. It also centralizes dependency management for the build tooling itself via \Build.Packages.props\ and a \packages.lock.json\, and supports automated release note generation and publishing to GitHub, NuGet, npm, and PyPI.

build · high confidence

The ArcTable library has been completely restructured to improve performance and data integrity. The internal storage now uses a sparse column representation (ArcTableValues) that automatically compresses constant columns and handles sparse data more efficiently, resulting in significant speed improvements for adding rows, columns, and retrieving data. The data model introduces a new CompositeCell union type with Term, FreeText, Unitized, and Data variants, replacing previous cell structures. To support this, a new IOType enum (Source, Sample, Data, Material) standardizes input/output column handling, and header names like "Raw Data File" are now normalized to "Data". Additionally, the system enforces unique table names within an ArcTables collection and includes robust hash collision handling for the Python runtime.

src/Core/Table · high confidence

The core library has been reorganized to introduce dedicated types for workflow and run management (ArcWorkflow, ArcRun) and a new Datamap structure for handling data contexts, replacing the previous flat table-based approach. This change also standardizes data file type labels to 'Data' in column headers, refactors ontology annotation handling for better hash consistency, and updates path resolution logic to ensure data file paths are absolute relative to the ARC-Root.

src/Core · high confidence

The JSON serialization logic for RO-Crate exports now includes comprehensive context mappings for ISA-Tab entities, ensuring that fields such as assay data files, study titles, and person details are correctly mapped to Schema.org and Bioschemas properties. This change adds context definitions for investigations, studies, assays, samples, materials, protocols, and processes, which resolves previous issues where fields like additionalProperties were lost during write-read cycles and ensures the conformsTo metadata is correctly mapped.

ARCtrl.Json · high confidence

The \src/ROCrate/LDTypes\ module has been restructured to include new type definitions for \Comment\, \ComputerLanguage\, \CreateAction\, and \DefinedTerm\, while significantly enhancing existing types like \ComputationalWorkflow\, \CreativeWork\, and \Dataset\. This update introduces stronger typing for CWL parameter values, adds support for automatic workflow and run profile exports, and ensures that creators and \dateCreated\ are correctly written to \WorkflowProtocol\. Additionally, default \programmingLanguages\ are now included in RO-Crate exports, and fixes address issues with \sdDatePublished\ key naming and the preservation of arbitrary date strings during conversion.

src/ROCrate/LDTypes · high confidence

The ROCrate module has been refactored to use a new, strongly-typed data model built around LDNode, LDRef, LDValue, and LDGraph classes, replacing the previous ROCrateObject/LDObject naming and inheritance structure. This change introduces dedicated classes for managing JSON-LD contexts (LDContext) with term resolution and mapping, and provides a new ArcROCrateMetadata class that explicitly conforms to RO-Crate 1.1. The update also includes helper extensions for DynamicObj to handle property casting and array resizing across Fable/Python backends, and adds a comprehensive context term definition file for Schema.org 1.2.

src/ROCrate · high confidence

The ContractIO module now performs all file system operations asynchronously, supporting .NET, JavaScript (Node.js), and Python runtimes. This change enables reading and writing ISA contracts (spreadsheet and text formats) and handling operations like create, update, delete, and rename without blocking the main thread, with a safeguard to prevent overwriting .gitkeep files unless explicitly forced.

src/ARCtrl/ContractIO · high confidence

This change introduces a new \ArcTable\ module within the \src/Spreadsheet/AnnotationTable\ location, providing a complete implementation for reading and writing ISA-Tab annotation tables. The new code replaces previous ad-hoc parsing with a structured approach using \CompositeHeader\, \CompositeColumn\, and \CompositeCell\ types to handle complex column hierarchies (such as Input/Output, Protocol, and Parameter groups) and their associated metadata (like Term Source REF and Accession Numbers). It includes logic to fix deprecated IO header formats, group columns by header type, and efficiently serialize/deserialize data to and from spreadsheet worksheets using the \FsSpreadsheet\ library.

src/Spreadsheet/AnnotationTable · high confidence

The \src/Core/Helper\ area now includes a suite of new utility modules that standardize data handling and parsing across the application. \Collections.fs\ provides specialized sequence, option, and dictionary helpers, including Python-compatible dictionary initialization to resolve Fable transpilation issues. \Identifier.fs\ introduces robust validation and path-generation logic for assay, study, workflow, and run identifiers, ensuring consistent file naming conventions. \HashCodes.fs\ implements cross-platform (Fable/Python/JS/.NET) string and object hashing to prevent collisions in the Python runtime. \Regex.fs\ centralizes regex patterns and active patterns for parsing ISA-tab column headers, while \Url.fs\ adds a configurable URI parser for ontology annotations. These changes improve data integrity, parsing accuracy, and cross-platform consistency for core metadata operations.

src/Core/Helper · high confidence

The ARCtrl module now includes a new resolver (CWLRunResolver) that recursively resolves CWL workflow step run references. When processing a workflow, the system looks up relative paths for nested steps, caches the resolved processing units to handle reuse, and updates the workflow structure in-place. This ensures that external workflow definitions referenced via run paths are correctly identified and integrated during execution.

ARCtrl · high confidence

The JSON handling for ArcTable, CompositeCell, CompositeHeader, and Template has been updated to support a new, more efficient compressed format alongside the existing standard format. The new implementation introduces dedicated encoder and decoder modules for cell, ontology annotation, and string tables to optimize storage size, while maintaining backward compatibility by automatically detecting and parsing the legacy 'values' structure in ArcTable JSON. This change affects how table data is serialized and deserialized, ensuring robustness against mutability issues and supporting compressed representations for better performance.

src/Json/Table · high confidence

The ARCtrl.Core library has been significantly restructured to improve transpiled JavaScript output and align with ISA-JSON standards. This change introduces a new type system where values are explicitly represented as \ScalarValue\ (replacing the previous \PropertyValue\ naming convention) and introduces dedicated types for process elements such as \Component\, \Factor\, \FactorValue\, \Material\, \MaterialAttribute\, \MaterialAttributeValue\, \Process\, \ProcessParameterValue\, \Protocol\, \ProtocolParameter\, \Sample\, and \Source\. Serialization logic has been updated to use \toStringObject\ for generating ISA-JSON compatible strings, and new helper modules like \SemVer\ and \Comment\ have been added to support versioning and metadata handling. These changes affect how experimental data, protocols, and process steps are modeled and serialized within the core library.

ARCtrl.Core · high confidence

Added CWL test fixtures for parsing and validation; Added Cypress UI tests for Vue components; Added JSON serialization tests for ArcTable, Assay, and core data models; Added JSON test fixtures for ISA-Tab and RO-Crate entities; Added JavaScript unit tests for ARCtrl components; Added Python unit tests for ArcCtrl components; Added SimpleARCWithCWL test fixture for ProteomIQon workflow validation; Added Web Bundling test project; Added YAML serialization tests for ValidationPackage and ValidationPackagesConfig; Added comprehensive test suite for ARCtrl core components; Added comprehensive test suite for CWL decoding and encoding; Added comprehensive test suite for WorkflowGraph; Added comprehensive unit tests for spreadsheet parsing and writing; Added core unit tests for ArcCtrl data models; Added performance testing framework for ArcTable operations; Added speedtest benchmarks for ArcTable operations; Added test contracts for ISA spreadsheet objects; Added test coverage for JSON Process and ProcessInput modules; Added test coverage for ROCrate JSON-LD parsing and serialization; Added test fixtures for ARC RO-Crate prototypes; Added test fixtures for IO contract and path sub-path finding; Added test fixtures for ISA-Tab spreadsheet metadata; Added test fixtures for SimpleARC IO validation; Added test fixtures for SimpleARCWithWR workflow and run contract handling; Added tests for FileSystemTree operations; Added tests for JSON decoder and validation logic; Added tests for JSON schema validation across .NET and JavaScript targets; Added tests for ValidationPackagesConfig extension methods; Added unit tests for ROCrate LDContext and LDNode components; Added unit tests for ValidationPackage and ValidationPackagesConfig; Consolidated test runner for all test suites; New test utilities and test object fixtures for cross-platform testing.

The .doc-scan directory has been updated to point to new commits for its constituent submodules, including ARCitect, Swate, arc-export, arc-validate-package-registry, arcCommander, brapi2arc, elab2arc, knowledgebase, and mira. This change reflects the underlying dependency updates mentioned in the commit message, ensuring the documentation scanning tools use the latest versions of these internal components.

.doc-scan · high confidence

The project has upgraded its build infrastructure to .NET 8 and Fable 5, enabling transpilation to both JavaScript and Python. Dependency management is now centralized via Directory.Packages.props, and key libraries have been updated: FsSpreadsheet to 7.0.1, DynamicObj to 8.0.0, and YAMLicious to 1.0.0. The Python runtime requirement is now Python 3.12+, and the JavaScript build tooling has shifted to Vite 7 and Vitest 3.

(dependencies) · high confidence

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

• CAI 58 → 57 (-1.3)
• Rubric changed (rubric-2026.09.15 → rubric-2026.10.1) — scores are not directly comparable.

• Code Health 74 → 74 (-0.0)
• Architecture 99 → 90 (-8.9)
• Maturity 63 → 63 (+0.2)
• Readiness 49 → 49 (-0.4)
• Security 59 → 62 (+2.9)
• Performance 60 (new)

• High CVE: [GHSA redacted] (package-lock.json)
• High CVE: [GHSA redacted] (package-lock.json)
• High CVE: [GHSA redacted] (package-lock.json)
• High CVE: [GHSA redacted] (poetry.lock)
• Hotspot: src/CWL/CWLTypes.fs (src/CWL/CWLTypes.fs)
• Hotspot: src/CWL/Decode.fs (src/CWL/Decode.fs)
• Hotspot: src/Core/Conversion.fs (src/Core/Conversion.fs)
• Members sharing a duplicated core (4 members, 50+ identical tokens) (src/ARCtrl/Conversion/Assay.fs)
• Members sharing a duplicated core (4 members, 50+ identical tokens) (src/Spreadsheet/ArcInvestigation.fs)
• Members sharing a duplicated core (7 members, 50+ identical tokens) (src/Spreadsheet/Metadata/Assays.fs)
• Off-boarding risk: anonymized user #1
• Off-boarding risk: anonymized user #2

• Documentation: no contributor guidance (README.md)
• Documentation: no project overview (README.md)
• High CVE: [GHSA redacted] (package-lock.json)
• High CVE: [GHSA redacted] (package-lock.json)
• High CVE: [GHSA redacted] (package-lock.json)
• High CVE: [GHSA redacted] (poetry.lock)
• High CVE: [GHSA redacted] (uv.lock)
• Members sharing a duplicated core (4 members, 50+ identical tokens) (src/ARCtrl/Conversion/Assay.fs)
• Members sharing a duplicated core (4 members, 50+ identical tokens) (src/Spreadsheet/ArcInvestigation.fs)
• Members sharing a duplicated core (7 members, 50+ identical tokens) (src/Spreadsheet/Metadata/Assays.fs)
• Off-boarding risk: anonymized user #1
• Off-boarding risk: anonymized user #2
• Outdated (npm): @fast-csv/format
• Outdated (npm): @fast-csv/parse
• Outdated (npm): @fslab/fsspreadsheet
• Outdated (npm): @nfdi4plants/arctrl
• Outdated (npm): @nfdi4plants/exceljs
• Outdated (npm): @types/node
• Outdated (npm): archiver
• Outdated (npm): archiver-utils
• …and 49 more

• 3 commits — 3 feature/other, 0 fixes

• (root) — 3 commits

• change: bump to 3.2.1
• change: bump to 3.2.2
• change: update fable dependencies

• Unchanged — 0 containers · 10 contexts · 14 edges

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

nfdi4plants/ARCtrl 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.