Skip to content
CAI
Software that uses CAICheck a score

johnynek/bosatsu

64.0

Adequate · 7 November 2026

102.4k

lines of production code

Scala

with C

4

measurements over time

CAI band scale
CAI trend line
CAI lens gauges

What this system is

Features

Add Bosatsu syntax highlighting for Visual Studio Code

This change introduces a new Visual Studio Code extension for the Bosatsu language, providing syntax highlighting for \.bosatsu\ files. The extension uses a TextMate grammar to highlight keywords, functions, structs, enums, comments, numeric and character literals, and string interpolation. It also includes a language configuration file to support auto-closing pairs and bracket matching. This is a syntax-only feature; semantic tokens and other IDE features are not yet included.

syntax/vscode · high confidence

Add Bosatsu workflow definitions and proto config demo

New Bosatsu source files define GitHub Actions workflows for CI, coverage reporting, web deployment, and releases, alongside a utility module with shared constants and step definitions. Additionally, a new example demonstrates encoding protobuf configuration payloads using the Bosatsu Proto library.

_test\workspace/Bosatsu/Example · high confidence

Add C runtime installation command

Introduces a new CLI command for installing the C runtime, allowing users to specify a local archive path, a download URL with an expected hash, or rely on the default GitHub release. The command supports configuring the build profile (release or debug) and automatically extracts the archive to the appropriate directory structure.

core/src/main/scala/dev/bosatsu/cruntime · high confidence

Add benchmarking tools and core evaluation infrastructure

Introduces CLI benchmarking utilities (CheckBenchmarkMain, EvalBenchmarkMain) for performance profiling and adds core evaluation infrastructure (Evaluation, Externals, FfiCall) to support runtime execution and external function calls.

repository · high confidence

Add in-repo Tree-sitter grammar for Bosatsu syntax highlighting

Introduces a new in-repo Tree-sitter grammar for the Bosatsu language, enabling syntax highlighting, folding, and basic token recognition in Neovim via nvim-treesitter. The grammar covers top-level package declarations, function and type definitions, imports, pattern matching, and control flow, with keywords like \matches\ explicitly recognized. It uses an external scanner for indentation handling and provides highlight, fold, and local-scope queries, though it is currently token-oriented rather than a fully structured AST.

syntax/tree-sitter-bosatsu · high confidence

Add protobuf code generation plugin and wire serialization runtime

Users can now generate Bosatsu code from .proto files using a new protoc plugin (ProtocPluginNodeMain) and utilize the new runtime library for serializing and deserializing protobuf data (Wire.bosatsu). The core module includes ProtoNaming.scala to handle name generation and package mapping for the generated code.

_cliJS/src/main/scala/dev/bosatsu/protobuf, core/src/main/scala/dev/bosatsu/protobuf, test\workspace/Bosatsu/Proto · high confidence

Added JVM benchmark suite for compiler and evaluation performance

A new JMH-based benchmark class (TestBench) has been added to measure the performance of the compiler's package resolution, type inference, and evaluation engine. The benchmarks include specific workloads such as calculating Gauss sums and solving Project Euler problem 4 (finding the largest palindrome product), allowing users to track regressions or improvements in compilation and execution speed.

bench/src · high confidence

Core compiler infrastructure and library utilities

This change introduces a suite of foundational components for the Bosatsu compiler core. It adds a new \MainModule\ that restructures the CLI, exposing top-level library commands and a \tool\ subcommand for lower-level file-based operations, while also supporting \--\ passthrough arguments for the \eval\ command. The diff implements a \Matchless\ compilation pipeline (\MatchlessFromTypedExpr\) that converts typed expressions into a match-less intermediate representation, including logic to resolve constructor data representations from imported interfaces. It also introduces a \Require\ macro for compile-time assertions, a \Nullable\ opaque type with inline fold/map/flatMap operations, and a \Region\ type packed into a \Long\ for source location tracking. Additionally, it provides various utility objects (\CollectionUtils\, \ListUtil\, \StringUtil\, \EditDistance\, \ParserHints\) and core data structures (\Expr\, \DefStatement\, \TypeParser\) that support parsing, type checking, and error reporting.

core/src/main/scala/dev/bosatsu · high confidence

Initial implementation of Clang C code generator

Added the ClangGen module, which generates C source code from the Bosatsu Matchless IR. This includes support for top-level function aliases, explicit and collision-proof synthetic identifiers, recovery of top-level lambdas, globally namespaced externals, and 62-bit small-int runtime support with int64 literal codegen.

core/src/main/scala/dev/bosatsu/codegen/clang · high confidence

Initial repository scaffolding and tooling setup for Bosatsu

This change establishes the foundational structure for the Bosatsu project, introducing the \bosatsu\ CLI launcher script that supports Java, Node.js, and native platforms, along with platform-specific wrappers (\bosatsuj\, \bosatsu\_node\). It adds configuration for the Scala 3 build (\.scalafmt.conf\, \.jvmopts\, \.sbtopts\), CI integration (\.travis.yml\, \.mergify.yml\, \codecov.yml\), and a Bazel build setup (\.bazelrc.travis\). The repository also includes a Tree-sitter grammar for Neovim syntax highlighting, a \protoc-gen-bosatsu\ plugin, and comprehensive test harnesses (\test\_cli.sh\, \test\_python.sh\, \testc\) for validating the compiler and runtime across different targets.

(repo-wide) · high confidence

Initial setup of the jsui frontend build and layout

The jsui directory now contains the foundational files for the web interface, including an HTML entry point that loads the compiled Scala.js bundle, a CSS stylesheet defining a responsive grid layout for code and output panels, and a Webpack configuration that resolves Node.js module fallbacks and excludes Scala.js bundles from source-map processing.

jsui · high confidence

Introduce Bosatsu Array collection with external bindings and helper functions

Adds a new \Bosatsu/Collection/Array\ module that exposes an external \Array\ type and a comprehensive set of operations including creation (\empty\, \tabulate\, \from\_List\), access (\get\, \get\_or\, \set\), transformation (\map\, \filter\, \flat\_map\, \reverse\, \flatten\), and reduction (\foldl\, \foldr\, \sumf\, \dotf\). The module also provides conversion helpers between Arrays, Lists, Strings, and Char arrays, and leverages \Int64\ for indexing and size operations.

_test\workspace/Bosatsu/Collection · high confidence

Introduce Bosatsu IO library with file, process, and standard I/O capabilities

This change adds the \Bosatsu/IO\ package, providing a new set of IO primitives for the Bosatsu language. It includes \Bosatsu/IO/Bytes\ for binary data handling, \Bosatsu/IO/Error\ for a structured error type, and \Bosatsu/IO/Std\ for standard input/output operations like \println\ and \read\_line\. The core \Bosatsu/IO/Core\ module exposes file operations (open, read, write, temp files), process management (spawn, wait, terminate), and time utilities, all wrapped in the \Prog\ effect system. The entry also includes test programs (\CreateModeMain\, \ProcessWaitMain\) demonstrating these new capabilities.

_test\workspace/Bosatsu/IO · high confidence

Introduce Bosatsu standard library prelude

The \core/src/main/resources/bosatsu/predef.bosatsu\ file now provides the core standard library for the Bosatsu language. This includes definitions for fundamental types such as \Bool\, \List\, \String\, \Int\, \Float64\, \Dict\, and \Tuple\ structures up to arity 32. It also exports a comprehensive set of built-in functions for boolean logic, arithmetic, list manipulation (including \foldl\_List\, \foldr\_List\, \map\_List\), string operations, and dictionary management, establishing the foundational API available to all Bosatsu programs.

core/src/main/resources · high confidence

Introduce C runtime with build system, benchmarks, and core library externals

The \c\_runtime\ directory now provides a complete C-based execution environment for Bosatsu programs. This includes a \Makefile\ that supports \debug\ and \release\ build profiles (defaulting to \-O3 -flto\), automatic dependency resolution for the Boehm GC and libuv via \pkg-config\ or platform-specific fallbacks, and an \install\ target for packaging. The runtime exposes externals for core Bosatsu libraries, including \Bosatsu/Collection/Array\ (with stable sorting and functional operations), \Bosatsu/IO/Bytes\ (binary data handling), \Bosatsu/Eval\ (lazy evaluation and flat-map loops), and \Bosatsu/Num/Int64\/\Float64\. A \bench.c\ benchmark suite is included to measure performance of integer and float operations, and a \boehm\_example.c\ demonstrates the garbage collector integration.

_c\runtime · high confidence

Introduce EDN-based serialization and structured CLI error handling

The tool now supports lossless EDN encoding and decoding for library show outputs, enabling structured, machine-readable data exchange alongside existing formats. This change introduces a new \Edn\ data model and codec infrastructure in the core library, allowing users to leverage EDN for precise serialization of package metadata and type information. Additionally, the CLI now uses a structured \CliException\ system for consistent error reporting, improving the clarity and reliability of command-line feedback.

core/src/main/scala/dev/bosatsu/tool · high confidence

Introduce Hashable typeclass with automatic derivation for Scala types

A new \Hashable\ typeclass has been added to the core hashing module, enabling automatic derivation of hash implementations for Scala case classes, enums, and other types via Scala 3 macros. This allows users to generate consistent hashes for complex data structures without writing manual hashing logic, supporting both primitive types and nested collections through provided instances and derivation capabilities.

core/src/main/scala/dev/bosatsu/hashing · high confidence

Introduce SMT library foundation with Z3 API support

Added the \dev.bosatsu.smt\ package containing core data structures and rendering utilities for SMT-LIB scripts. This includes \LoweredBool\ for representing lowered boolean expressions, \SmtScriptScope\ for tracking variable declarations and scope validity, and \SmtLibRender\/\SmtToSExpr\ for converting internal SMT representations into SMT-LIB formatted output, laying the groundwork for Z3 integration.

core/src/main/scala/dev/bosatsu/smt · high confidence

Introduce Scala.js-specific platform IO implementation

Added Fs2PlatformIO, a new implementation of the PlatformIO interface tailored for the Scala.js runtime. This component provides the underlying file system, process execution, and environment access logic required for the CLI to operate in JavaScript environments, utilizing fs2 for asynchronous I/O and cats-effect for side-effect management.

cliJS/src/main/scala/dev/bosatsu · high confidence

Introduce Scala.js-specific runtime implementations for Bosatsu core types

The core runtime now includes platform-specific implementations for Scala.js, enabling the Bosatsu compiler to function in JavaScript environments. This adds a \BosatsuInt\ type that optimizes integer operations by using \java.lang.Integer\ for small values and \java.math.BigInteger\ for large ones, including a workaround for broken Scala.js \BigInteger.xor\ behavior. A \Par\ object provides a no-op parallelism abstraction (using \cats.Id\) to satisfy interface requirements without actual concurrency, while \Platform\ detects the operating system via Node.js or browser user agents. Additionally, \StackSafe\ handles JavaScript-specific stack overflow errors (such as \RangeError\ or "maximum call stack size exceeded") to prevent crashes during deep recursion.

core/.js/src/main · high confidence

Introduce filesystem-based compile cache with content-addressable storage

The compiler now supports a persistent compile cache that stores artifacts on disk using content-addressable storage (CAS) keyed by Blake3 hashes. This change introduces the \CompileCache\ and \InferCache\ abstractions, which manage key generation, encoding, and decoding of compiled packages. The cache uses raw source hashes to skip parsing on cache hits and includes a default inference phase (\tool-default-v1\) that applies loop-recursion lowering, normalization, and unused-discard passes. A \noop\ cache implementation is also provided for environments where caching is disabled or not needed.

core/src/main/scala/dev/bosatsu/cache · high confidence

Introduction of TypeEnv for managing type aliases and constructors

The core type environment now explicitly tracks type aliases alongside defined types and constructors. This change allows the system to resolve and store type aliases, enabling users to define and use shorthand names for complex types within their packages. The TypeEnv class provides methods to add, retrieve, and iterate over these aliases, ensuring they are handled consistently with other type definitions during type checking and resolution.

core/src/main/scala/dev/bosatsu/rankn · high confidence

Introduction of TypedAst protobuf schema

A new protobuf definition file (TypedAst.proto) has been added to the proto module, establishing the serialization format for the compiler's typed abstract syntax tree. This schema defines the structure for core type system elements, including type kinds, variance, type variables, universal and existential quantification, type application, and type aliases. It also specifies the layout for defined types, constructors, function parameters with default values, and package interfaces, enabling the typed AST to be exchanged or stored in a standardized binary format.

proto · high confidence

Introduction of pattern matching and file-loading core components

The library now includes core infrastructure for pattern matching and compile-time resource loading. A new \Matcher\ trait in \dev.bosatsu.pattern\ provides a generic interface for matching elements with support for mapping results and specific matchers for equality, integers, and boolean functions. This is complemented by a \Splitter\ abstraction that allows splitting sequences (such as strings and lists) based on these matchers, handling both exact character/codepoint splits and 'any element' splits. Additionally, a \Macro\ object in \dev.bosatsu\ enables loading file contents as string literals at compile time, supporting paths relative to the project and a fallback location under \external/org\_bykn\_bosatsu/\.

base, core/src/main/scala/dev/bosatsu/pattern · high confidence

Lean proofs for well-foundedness of trusted delayed projections and fuel-free evaluation

Added a new \lean\_proofs\ module containing machine-checked Lean proofs that justify the recursion checker's handling of trusted delayed projections (thunks and lazy values) and a fuel-free \Eval\ interpreter. Specifically, \TrustedForceProjection\ proves that extending structural descent with trusted thunk/lazy force steps preserves well-foundedness by strictly decreasing a hidden rank witness. \TrustedEvalProjection\ extends this to show that adding trusted \Eval::eval\ steps remains well-founded and that the \flat\_map\ callback binder correctly projects to the evaluated input. \EvalNoFuel\ provides a termination proof for a bounded-continuation evaluator using a static work bound, while \EvalFuelExistence\ proves that a naive \Eval\ shape always terminates semantically and has a corresponding finite fuel witness.

_lean\proofs · high confidence

New CI and release automation scripts for C runtime, publishing, and validation

Added a suite of new scripts to support the C backend and library publishing workflows. \scripts/test\_c\_sanitizers.sh\ and \scripts/test\_c\_valgrind.sh\ run the C runtime and transpiled code under AddressSanitizer/UBSan and Valgrind memory checks respectively. \scripts/c\_runtime\_ci\_env.py\ validates vendored C dependencies (libuv, libgc) and emits environment variables for CI builds. \scripts/publish\_bosatsu\_libs.sh\ handles fetching and publishing Bosatsu libraries with optional dry-run support, while \scripts/verify\_release\_tag.py\ ensures sbt versioning matches git tags. Additional scripts include \scripts/test\_basic.sh\ for core CLI tests, \scripts/test\_launcher\_passthrough.sh\ to verify argument forwarding, \scripts/test\_tree\_sitter.sh\ for grammar validation, \scripts/check\_proofs.sh\ for proof suite execution, and \scripts/bin/nc\ as a wrapper for protoc bridge communication.

scripts · high confidence

New JavaScript API for evaluating Bosatsu code

The jsapi module now exposes a \Bosatsu\ object to JavaScript environments, providing \evaluate\ and \evaluateJson\ methods. These functions allow external applications to execute Bosatsu code by passing source files and a main package or file path, returning either the rendered evaluation result (with type information) or an error object. This enables programmatic interaction with the Bosatsu toolchain from JavaScript-based interfaces or build tools.

jsapi · high confidence

New graph data structures and path analysis utilities

Added three new source files to the core graph module: \CanPromise\, a trait defining an abstraction for asynchronous promise-based computations; \Dag\, a new immutable Directed Acyclic Graph implementation featuring layer-based topological sorting, cycle detection via clustering, and transitive closure calculation; and \Paths\, a utility object providing functions to enumerate all simple paths and cycles between nodes in a graph, with support for annotated edges.

core/src/main/scala/dev/bosatsu/graph · high confidence

New set-relation and pattern-matching operations for exhaustiveness checking

Added \Relatable\ and \SetOps\ traits in the \dev.bosatsu.set\ package to support advanced set-relation logic and pattern-matching exhaustiveness analysis. \Relatable\ defines how to compare values for subset, superset, intersection, and disjointness relationships, with specific implementations for Scala \Set\ and universal equality. \SetOps\ builds on this to provide operations like \difference\, \unifyUnion\, and \missingBranches\, which are used to calculate which pattern branches are unreachable or missing to ensure total pattern matching. This includes a \greedySearch\ algorithm to optimize the order of applying differences when determining missing branches.

core/src/main/scala/dev/bosatsu/set · high confidence

Removals

Removal of Hindley-Milner type inference implementation

The file src/main/scala/example/Hello.scala, which contained the Scala implementation of Hindley-Milner type inference (including definitions for expressions, types, and the inference engine), has been deleted from the project.

src/main · high confidence

Behavioural changes

4 commits (0 fixes) modifying core/src/main/scala/dev/bosatsu/library

A change to existing behaviour in core/src/main/scala/dev/bosatsu/library — 4 commits, 2 files: “Move package name to dev.bosatsu”; “Big CLI refactor (\#1567)”; “Reformat with scalafmt 3.10.7”; and 1 more (refs \#1567, \#2301).

core/src/main/scala/dev/bosatsu/library · medium confidence · unverified

CLI application entry point and platform IO abstraction

The CLI now uses a new \Main\ object that initializes the application with the CPU starvation checker disabled to prevent performance issues in long-running processes. It delegates execution to \PathModule\, which wires the core logic to a new \IOPlatformIO\ implementation. This platform layer provides the concrete \cats.effect.IO\ operations for file system access, environment variables, and system command execution, ensuring the CLI runs correctly on the target platform.

cli/src/main · high confidence

Disable CPU starvation checker in CLI applications

The CLI entry point now disables the CPU starvation checker by setting the initial delay to infinity. This behavioral change prevents the runtime from interrupting or flagging long-running CLI processes as starved, ensuring smoother execution for tools that may legitimately hold CPU resources for extended periods.

cliJS/src/main/scala/dev/bosatsu/tool · high confidence

Introduce new Matchless-based compilation pipeline and namespace abstractions

The code generation core now utilizes a new \CompilationNamespace\ and \CompilationSource\ architecture to manage the Matchless IR compilation process. This change introduces support for global inlining and configurable local pass options, allowing the compiler to optimize code structures more effectively. Additionally, new utilities for identifier escaping (\Idents\) and a generic \Transpiler\ trait are added to handle output rendering and argument parsing, forming the foundation for the updated Matchless IR support.

core/src/main/scala/dev/bosatsu/codegen · high confidence

Introduce new ff4s-based web UI for code evaluation and testing

The web interface has been rewritten using the ff4s framework to provide a playground for Bosatsu code. Users can now enter code snippets and trigger three distinct actions—evaluate, test, and show—via dedicated buttons. These actions are routed through the underlying tooling (using the 'tool' prefix commands) to produce HTML-colored output, which is displayed in an output panel along with execution duration. The UI automatically manages state persistence in the browser's local storage and injects a default package name for snippets that lack an explicit header, ensuring seamless execution in the web demo environment.

jsui/src/main · high confidence

JVM-specific core runtime implementations

This change introduces platform-specific implementations for the JVM target, replacing generic or cross-platform logic with optimized JVM-native code. It adds a new \BosatsuInt\ type that uses \Long\ for performance and falls back to \BigInteger\ for arbitrary-precision arithmetic, ensuring correct behavior for large integers. A new \Par\ object provides parallel computation support using Scala \Future\ and \ExecutionContext\, enabling concurrent operations on the JVM. The \Platform\ object now exposes JVM-specific constants and OS detection. Runtime I/O and file system operations (such as reading/writing files, spawning processes, and managing directories) are wired to JVM-native implementations via \PredefIoCorePlatform\. Additionally, stack-safety is improved with a \StackSafe\ utility to catch \StackOverflowError\, and a \Sha256Hash\ utility is added for cryptographic hashing.

core/.jvm/src/main · high confidence

Major CLI refactor introduces new tool subcommands and stricter dependency handling

The \bosatsu tool\ command-line interface has been significantly restructured, replacing the previous command set with a new suite of subcommands: \check\ (type checking), \test\ (test discovery and execution), \transpile\ (code generation to Python/Clang), \json\ (JSON/YAML evaluation and traversal), \doc\ (markdown documentation), \eval\ (expression evaluation with optional \--run\ mode), \deps\ (dependency graph output), \show\ (IR/typed expression display), \assemble\ (library assembly), \extract-iface\ (interface extraction), and \protoc-plugin\ (protobuf code generation). This refactor enforces stricter dependency visibility rules, requiring that dependencies used in \assemble\ operations be full \.bosatsu\_lib\ files rather than interface-only \.bosatsu\_ifacelib\ files, and introduces explicit public/private dependency separation across commands. Users will now interact with a more granular, workflow-oriented CLI that supports features like YAML output for JSON commands, \--run\ passthrough arguments for evaluation, and compile caching.

_core/src/main/scala/dev/bosatsu/tool\command · high confidence

Test coverage

Add end-to-end C code generation tests; Add property-based tests for Python code generation; Add test coverage for Int64 runtime, Array operations, and compiler internals; Added CLI test coverage for JSON parity, IO platform, and Protobuf plugin; Added JVM integration tests for IO, Z3, and Tree-sitter; Added JVM tests for Python code generation and Array runtime; Added regression tests for JSUI state serialization and Store command handling; Added tests for C runtime dependency manifest validation; Added tests for Fs2PlatformIO path resolution; Added tests for Node.js IO core functionality; Added tests for core\_alpha library configuration exports; Expanded test workspace with new Bosatsu examples and property-based tests; Removed obsolete type inference tests.

Dependencies

Upgrade build infrastructure to sbt 1.13 and modernize dependency management

The build system has been upgraded from sbt 0.13.16 to 1.13.0, enabling support for modern Scala features and plugins. The project has migrated its dependency management to use \Def.setting\ with cross-version support (%%%) for libraries like Cats, FS2, and http4s, ensuring correct artifact resolution across Scala versions. Additionally, the plugin suite has been updated to include sbt-assembly 2.5.0, sbt-scalajs 1.22.0, sbt-native-image 0.5.0, and sbt-scoverage 2.4.4, while replacing older testing frameworks with Munit 1.3.6 and ScalaCheck 1.20.0.

project · high confidence

Upgrade to Scala 3.8.2 and restructure build for cross-compilation

The project has upgraded its primary language version from Scala 2.13 to Scala 3.8.2, enabling strict equality checks and modern compiler warnings. The build system has been restructured to support cross-compilation to both JVM and JavaScript platforms using sbt cross-project, replacing the previous single-platform setup. Additionally, new npm package manifests have been added for the tree-sitter grammar and VS Code extension, and the JavaScript build tooling now includes a \package-lock.json\ with pinned versions for Webpack and related dependencies.

(dependencies) · high confidence

Housekeeping

Removal of temporary attach process file

The temporary file \.attach\_pid26384\ in the bench directory has been removed. This file is typically a transient artifact created by Java attach mechanisms and does not represent a functional change to the product.

bench · 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 57 → 64 (+6.7)
  • Rubric changed (rubric-2026.10.5 → rubric-2026.11.2) — scores are not directly comparable.

Lenses

  • Code Health 80 → 80 (+0.0)
  • Architecture 92 → 88 (-4.1)
  • Maturity 52 → 86 (+33.5)
  • Readiness 59 → 58 (-1.1)
  • Security 54 → 56 (+2.4)
  • Performance 77 → 89 (+11.9)

Resolved (20)

  • ADR has no Consequences section (docs/design/1798-require-shadowed-bindings-to-have-the-same-type.md)
  • ADR has no Consequences section (docs/design/2216-remove-unsound-cast-in-compilecache.md)
  • ADR has no Decision and Consequences section (docs/design/1908-lib-build-should-allow-only-giving-the-e-exe-out-option.md)
  • ADR has no Decision and Consequences section (docs/design/2073-add-doc-base-urls-to-libraries.md)
  • ADR has no Decision and Consequences section (docs/design/2274-add-matchless-support-to-show.md)
  • ADR has no Decision and Consequences section (docs/design/2365-specify-the-portable-process-stop-and-status-contract.md)
  • ADR has no Decision and Consequences section (docs/design/414-consider-implementing-caching-of-compiled-files.md)
  • ADR has no Decision section (docs/src/main/paradox/design-docs/compiler_leveraging_type_inhabitedness.md)
  • ADR has no Decision section (docs/src/main/paradox/design-docs/prog_concurrency_design.md)
  • ADR has no Decision section (docs/src/main/paradox/design-docs/quantifier-evidence-design.md)
  • Checkable ADR rule enforced only by prose: Issue #1738 Design: Hoist Loop-Invariant Lets Out of Loop Bodies (docs/design/1738-hoist-loop-invariant-lets-out-of-loop-bodies.md)
  • Checkable ADR rule enforced only by prose: Issue #2224 Design: Minimize core_alpha Exports (docs/design/2224-remove-unneeded-packages-from-exports.md)
  • Decision and consequences are present but trade-offs (e.g. vendoring libuv adds surface area, static linking burden) are not stated (docs/roadmap/2340-add-basic-support-for-libuv-in-c-backend.md)
  • High CVE: [GHSA redacted] (jsui/.js/package-lock.json)
  • Low CVE: [GHSA redacted] (core/.js/package-lock.json)
  • Medium CVE: [GHSA redacted] (jsui/.js/package-lock.json)
  • Medium CVE: [GHSA redacted] (jsui/.js/package-lock.json)
  • Medium CVE: [GHSA redacted] (core/.js/package-lock.json)
  • Off-boarding risk: anonymized user #1
  • Outdated: com.google.protobuf:protobuf-java-util

New (112)

  • ADR declares no status (docs/src/main/paradox/design-docs/issue_1718_instantiate_pushdown_unification_plan.md)
  • Classify ADR enforcement: Add Prog::Var (docs/design/2182-add-prog-var.md)
  • Classify ADR enforcement: Add Transparent Type Aliases (docs/design/2239-type-aliases.md)
  • Classify ADR enforcement: Add --warn and --lax lint modes to lib check and lib test (docs/design/2192-less-strictness-in-lib-check-mode.md)
  • Classify ADR enforcement: Add postponable recursion-form lints for recur and loop (docs/design/2227-add-a-lint-for-using-recur-instead-of-loop.md)
  • Classify ADR enforcement: Canonicalize opaque external declarations as external type (docs/design/2427-we-should-change-external-struct-to-external-type.md)
  • Classify ADR enforcement: Change todo behavior across strict, warn, and lax check modes (docs/design/2219-change-todo-behavior-in-type-check-mode.md)
  • Classify ADR enforcement: Code Plan #2323 (docs/code-plans/2323-silence-deprecated-referenced-dynamically-warnings-from-vendored-bdwgc-on-macos.md)
  • Classify ADR enforcement: Code Plan #2331 (docs/code-plans/2331-allow-binding-if-matches-syntax-in-patterns.md)
  • Classify ADR enforcement: Code Plan #2334 (docs/code-plans/2334-scalawasiz3-failure.md)
  • Classify ADR enforcement: Code Plan #2344 (docs/code-plans/2344-add-libuv-to-the-vendored-c-runtime-dependency-pipeline.md)
  • Classify ADR enforcement: Code Plan #2349 (docs/code-plans/2349-introduce-a-libuv-owned-prog-runtime-loop-skeleton.md)
  • Classify ADR enforcement: Code Plan #2351 (docs/code-plans/2351-add-suspend-and-resume-support-for-libuv-backed-prog-effects.md)
  • Classify ADR enforcement: Code Plan #2353 (docs/code-plans/2353-migrate-time-sleep-and-environment-c-io-effects-onto-libuv-runtime-plumbing.md)
  • Classify ADR enforcement: Code Plan #2356 (docs/code-plans/2356-migrate-file-and-directory-c-io-effects-to-libuv-backed-operations.md)
  • Classify ADR enforcement: Code Plan #2358 (docs/code-plans/2358-implement-libuv-backed-process-spawn-and-wait-for-c-io-core.md)
  • Classify ADR enforcement: Code Plan #2362 (docs/code-plans/2362-harden-c-backend-libuv-coverage-and-ci-validation.md)
  • Classify ADR enforcement: Code Plan #2367 (docs/code-plans/2367-prepare-process-state-for-idempotent-wait-and-status-queries.md)
  • Classify ADR enforcement: Code Plan #2369 (docs/code-plans/2369-implement-portable-terminate-kill-poll-and-wait-timeout-apis.md)
  • Classify ADR enforcement: Code Plan #2373 (docs/code-plans/2373-implement-managed-process-cleanup-helper.md)
  • …and 92 more

Changes since last survey

  • 2 commits — 2 feature/other, 0 fixes

By area

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

Notable commits

  • change: Configure repo-owned MergeXO container setup (#2456)
  • change: Update sbt, scripted-plugin to 1.13.1 (#2454)

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

johnynek/bosatsu 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 117d62bafe58d61192de07b23eecbfeaa0f05802 — 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-5f8314471808.