BeaconCMS/beacon
59.7
Adequate · 13 November 2026
35.8k
lines of production code
Elixir
with Zig
8
measurements over time
What this system is
Beacon is a Phoenix LiveView-based Content Management System that manages multiple sites through a declarative, extensible architecture. It features a platform-agnostic template engine with a custom AST parser, a GraphQL data layer for dynamic content, and a native Zig-based CSS compiler for Tailwind styles. The system supports structured content modeling, media asset management with S3 storage, and a lifecycle API for customizing page rendering and data processing workflows.
How it got here
2021–2022 — Core library initialization and legacy cleanup
17 changes.
This period established the foundational Beacon CMS core library, introducing a supervisor-based architecture with caching, circuit breakers, and lifecycle APIs. It simultaneously removed legacy Ecto schemas, dynamic module loaders, and outdated web interface components to align with the new structure. The work was supported by comprehensive configuration setup and expanded integration testing infrastructure.
2023 — Beacon core architecture and media library expansion
20 changes.
This period focused on establishing the foundational architecture for the Beacon content management system, introducing a custom template AST parser, structured content modeling, and a pluggable media library with S3 support. Significant effort was also dedicated to enhancing the frontend experience through Tailwind CSS integration, a dedicated JavaScript client for dynamic updates, and comprehensive test coverage across the new core subsystems.
2024–2026 — GraphQL and CSS infrastructure overhaul
23 changes.
This period focused on rebuilding the core data and rendering layers, introducing a dedicated GraphQL data layer and a declarative action engine to replace legacy mechanisms. It also implemented a high-performance, Zig-based CSS compiler with a three-tier storage system to replace the previous Tailwind CLI approach. Comprehensive test suites were added to validate these new architectural components, including SEO, caching, and content management features.
Features
Add beacon\_router\_scope.ex template for install generator
The install generator now includes a new \beacon\_router\_scope.ex\ template that generates a router scope block. This template uses the \Beacon.Router\ module and defines a browser pipeline that mounts a beacon site, utilizing the \path\ and \site\ variables passed from the generator to configure the route.
priv/templates · high confidence
Added Zig build configuration for the beacon\_css library
The native beacon\_css component now includes a standard Zig build setup, defining a library target named 'beacon\_css' and a unit test step. The project requires Zig version 0.15.2 or higher and includes a .gitignore file to exclude build artifacts (.zig-cache/ and zig-out/).
native · high confidence
Added caching support via Stale protocol
Introduced a new \Beacon.Web.Cache.Stale\ protocol and its implementations to enable HTTP caching (ETag and Last-Modified headers) for schema structs. This allows the web layer to efficiently cache responses by deriving cache keys from struct fields and associations, improving performance for repeated requests.
lib/beacon/web/cache · high confidence
Initial configuration setup for Beacon, Phoenix, and test environments
This change introduces the foundational configuration files for the application. It sets up the main \config.exs\ with default settings for ID generation and JSON libraries, and defines development-specific build pipelines for esbuild (including Tailwind CSS bundling) and Tailwind. It also establishes the \test.exs\ environment, configuring the Ecto repository, logging, session options, and specific endpoint settings for test proxies and sites, along with mock AWS credentials for integration testing.
config · high confidence
Introduce Beacon CMS core library with site lifecycle, caching, and extensibility
This change adds the foundational \lib/beacon\ library, establishing Beacon as a Phoenix LiveView-based Content Management System. It introduces a supervisor-based architecture for managing multiple sites, each with configurable modes (\:live\, \:testing\, \:manual\) and lazy loading. Key capabilities include a stampede-safe ETS cache (\Beacon.Cache\) with TTL support, a circuit breaker (\Beacon.CircuitBreaker\) to prevent cascading 500 errors, and a Lifecycle API that allows users to inject custom steps into page loading, rendering, and asset upload processes. The library also provides core content management APIs for layouts, pages, components, and media assets, along with collection-based dynamic meta tags and JSON-LD resolution for SEO.
lib/beacon · high confidence
Introduce Beacon.Web module and vendor Heroicons
The library now includes a new \Beacon.Web\ module that centralizes web-related functionality, providing custom \assign\ and \assign\_new\ functions that raise errors for reserved keys like \:beacon\, and macro helpers to configure Phoenix controllers, LiveViews, and components with the new \Beacon.Web.Layouts\. Additionally, the \heroicons\_elixir\ package has been vendored into \Beacon.Heroicons\ to avoid namespace conflicts, making the icon library available directly within the Beacon namespace.
lib · high confidence
Introduce Zig-based CSS compilation with three-tier storage and JS config parsing
Beacon now replaces the previous Tailwind CLI approach with a new architecture centered on a Zig NIF compiler for CSS generation. This change introduces a \CandidateExtractor\ to identify CSS classes from templates, a \ThemeParser\ to convert Tailwind v4 JavaScript config files into JSON for the NIF, and a \Storage\ module implementing a three-tier system (ETS for hot in-memory access, optional S3 for warm durable storage, and recompilation for cold misses). The S3 warm tier is optional and operates in ephemeral mode if no bucket is configured. Additionally, the theme parser specifically handles Tailwind v4 requirements by splitting \fontSize\ values into separate size and line-height variables.
lib/beacon/css · high confidence
Introduce comprehensive SEO and layout infrastructure for Beacon.Web
The application now includes a new \runtime\ layout template that automatically injects essential SEO metadata, including canonical links, robots directives, schema.org data, and dynamic page titles. This layout also handles the inclusion of CSRF tokens, live socket connections, and the necessary CSS/JS assets for the Beacon runtime. Additionally, new \app\ and \dynamic\ layout templates provide consistent structural wrappers and flash message handling for different rendering contexts.
lib/beacon/web/components/layouts · high confidence
Introduce dedicated GraphQL data layer with query execution and caching
Beacon now includes a new GraphQL data layer in \lib/beacon/graphql\ that replaces the previous \DataStore\ and \live\_data\ mechanisms. This layer provides a dedicated Finch HTTP client for GraphQL requests, complete with circuit breaker protection to prevent connection pool exhaustion during self-calls. It features a \QueryExecutor\ that handles topological sorting of page queries to respect dependencies, parallel execution of independent queries, and automatic unwrapping of single-key responses for easier template usage. The system includes an \EndpointCache\ for storing endpoint configurations in ETS, a \ResponseCache\ for stampede-safe query result caching, and an \OperationAllowlist\ to restrict which GraphQL operations can be executed. Additionally, it supports schema introspection and SDL parsing, variable resolution from path/query params and prior results, and type coercion for standard GraphQL scalars.
lib/beacon/graphql · high confidence
Introduce native Zig-based CSS compiler for static utilities and variants
The \native/beacon\_css\ module now provides a native Zig implementation for compiling CSS, starting with Phase 1 support for static utility classes (such as display, position, and flexbox) and variant prefixes (including hover, focus, responsive breakpoints, and dark mode). This change introduces the core parsing logic for candidate strings, a static utility map, variant resolution, and a CSS emitter that outputs minified styles wrapped in \@layer\ blocks, laying the groundwork for future functional utilities and theme resolution.
_native/beacon\css · high confidence
Introduce platform-agnostic template AST and recursive-descent parser
Beacon now uses a new, platform-agnostic template AST system that replaces the previous Floki-based parser with a custom recursive-descent parser. This change introduces a structured intermediate representation with six node types (element, text, expression, conditional, loop, and fragment) and a dedicated expression parser for handling interpolations, filters, and control flow. It also includes a component expander to inline component references at publish time and a HEEx converter to migrate existing Phoenix LiveView templates to the new syntax. Users benefit from a more robust and consistent template rendering pipeline that is decoupled from specific HTML parsing libraries.
lib/beacon/template · high confidence
Introduce snippet helpers for custom Elixir code in templates
Users can now define and execute custom Elixir code blocks (snippet helpers) directly within templates via a new \helper\ tag. This feature adds a \beacon\_snippet\_helpers\ schema to store helper definitions scoped by site, name, and body, along with a Solid parser integration that allows templates to invoke these helpers by name. The implementation delegates execution to \Beacon.RuntimeRenderer.render\_snippet\_helper\, enabling dynamic content generation within the rendering pipeline.
lib/beacon/content/snippets · high confidence
Introduces Beacon JS for non-blocking CSS warming and meta-tag updates
A new \beacon.js\ (and its minified counterpart) has been added to \priv/static\ to enable non-blocking CSS warming. This script listens for \phx:beacon:css-ready\ events to update the runtime stylesheet and handles \phx:beacon:page-updated\ events to dynamically inject meta tags while preserving the CSRF token. It also integrates with existing LiveView sockets by merging any user-defined \BeaconHooks\ into the LiveSocket hooks, ensuring custom JS hooks are preserved during the beacon initialization process.
priv/static · high confidence
Introduces Tailwind CSS configuration with Phoenix LiveView variants
The assets directory now includes a Tailwind CSS setup, featuring a configuration file that registers custom variants for Phoenix LiveView states (phx-click-loading, phx-submit-loading, phx-change-loading) alongside the @tailwindcss/forms and @tailwindcss/typography plugins. This is supported by a new CSS entry point (beacon.css) importing Tailwind's base, components, and utilities, as well as ESLint and Prettier configuration files to standardize code formatting and linting within the assets folder.
assets · high confidence
Introduces content modeling and extensibility schemas
Beacon now supports structured content collections and user-defined page fields, allowing editors to define custom data schemas (like blog posts or products) with specific layouts and SEO mappings. The system also introduces reusable UI components with defined attributes and slots, GraphQL data integration for dynamic page content, and robust versioning via page and layout snapshots. Additionally, it adds site-wide event handling (JS hooks, LiveView event/info handlers), error page customization, and automatic redirect management to improve site maintenance.
lib/beacon/content · high confidence
Introduces platform-agnostic template rendering with built-in filters
The Beacon client now supports a platform-agnostic JSON AST system for template rendering. This change adds a new \Beacon.Client.Filters\ module providing built-in data transformation filters (such as date formatting, text manipulation, and collection utilities) and a \Beacon.Client.LiveViewCompiler\ that compiles the AST into Phoenix LiveView rendered structs, enabling consistent template rendering across different platforms.
lib/beacon/client · high confidence
Introduces the Beacon runtime JavaScript client
A new beacon.js file is added to handle the client-side logic for the Beacon feature. This script initializes a Phoenix LiveView socket (using a configurable path and CSRF token) and allows host applications to inject custom JavaScript hooks via the global BeaconHooks object. It also listens for specific Phoenix events to dynamically update the page's CSS stylesheet and meta tags (excluding the CSRF token) during navigation or updates.
assets/js · high confidence
Live page updates with configurable notification or automatic refresh
PageLive now subscribes to page render and GraphQL cache invalidation events, allowing users to see content changes in real-time. Depending on the site's live update mode, updates are either applied automatically, trigger a manual 'Refresh' notification banner (with a customizable template), or are ignored (manual mode). The component also handles CSS warming by showing a placeholder until styles are ready, then redirects to ensure the final layout is correct.
lib/beacon/web/live · high confidence
Media Library assets now support custom fields and S3 storage providers
Users can now define custom data fields for media assets (such as alt text) via the new \Beacon.MediaLibrary.AssetField\ behavior, which are stored in the asset's \extra\ map and rendered in the Beacon Admin interface. Additionally, the Media Library has been refactored to use a pluggable provider architecture (\Beacon.MediaLibrary.Provider\), with a built-in S3 provider (\Beacon.MediaLibrary.Provider.S3\) that allows storing and serving assets in external buckets instead of the local database, supporting both signed and unsigned URLs.
_lib/beacon/media\library · high confidence
New Mix generator tasks for sites, proxy endpoints, and Tailwind safelists
This change introduces several new \mix beacon.\*\ tasks to help developers scaffold and configure Beacon sites within their Phoenix applications. \mix beacon.gen.site\ generates a new site endpoint with support for custom hosts, ports, and session configurations, including a \--host-dev\ option for local development with multiple sites. \mix beacon.gen.proxy\_endpoint\ creates a ProxyEndpoint to serve multiple domains. \mix beacon.gen.safelist\ generates a module that automatically extracts and validates Tailwind CSS class names from source files at compile time, ensuring no classes are purged. \mix beacon.gen.tailwind\_config\ sets up the Tailwind configuration. These tasks simplify the initial setup and ongoing maintenance of Beacon sites.
lib/mix · high confidence
New declarative action engine with GraphQL integration and security validation
The Beacon platform introduces a new declarative action system that replaces the previous DataStore and live\_data mechanisms. This change adds an interpreter that executes action documents containing steps for navigation, state management, DOM manipulation, and data fetching via a GraphQL client. To ensure reliability and safety, the system includes a validator that checks action structure and verifies that referenced GraphQL endpoints exist, as well as a security module that signs and verifies action documents using HMAC-SHA256 to prevent tampering. Additionally, a new encrypted binary type is added to support secure data storage.
lib/beacon/actions, lib/beacon/encrypted · high confidence
New default and image processing pipeline for media uploads
The media library now includes a default processor that handles basic metadata extraction and an image processor that converts uploaded images to WebP format. The image processor also automatically generates a 200px thumbnail and a 480px width variant, saving these derived assets to the library and sending them to CDNs.
_lib/beacon/media\library/processors · high confidence
New lifecycle hooks for assets, pages, and templates
This change introduces dedicated lifecycle modules (\Beacon.Lifecycle.Asset\, \Beacon.Lifecycle.Page\, and \Beacon.Lifecycle.Template\) that allow users to hook into specific stages of the content and media workflow. For assets, it adds an \:upload\_asset\ stage to process uploads (including WebP thumbnail and variant generation) and a \:delete\_uploaded\_asset\ stage for cleanup. For pages, it provides explicit callbacks for \:after\_create\_page\, \:after\_update\_page\, \:after\_publish\_page\, and \:after\_unpublish\_page\ to run logic after database transactions. For templates, it exposes \:load\_template\ and \:render\_template\ stages, enabling custom processing during template loading and rendering, with validation to ensure correct input/output types and format configurations.
lib/beacon/lifecycle · high confidence
New web component library and UI infrastructure
This release introduces a new \Beacon.Web\ component library, replacing the previous \BeaconWeb\ namespace. It provides a suite of reusable UI components including a modal dialog, flash notices, and a simple form builder in \CoreComponents\, alongside layout helpers for serving assets, rendering dynamic page titles, and generating SEO meta tags in \Layouts\. Additionally, it adds specific components for media handling (\image\_set\, \thumbnail\), a non-blocking CSS warming placeholder to improve initial load experience, and a live-update notification bar for content changes.
lib/beacon/web/components · high confidence
New web infrastructure: page assigns, caching, data source helpers, and site maps
This change introduces several new modules in the web layer that enhance how pages are rendered and served. BeaconAssigns provides a read-only container for current page context (site, path, query params) accessible via @beacon in templates and handlers. Cache adds HTTP caching support with ETag and Last-Modified headers for assets. DataSource handles page title interpolation and meta tag generation, allowing dynamic overrides. Additionally, RobotsTxt and SitemapXML modules are added to generate per-site robots.txt and sitemap.xml files respectively.
lib/beacon/web · high confidence
Removals
Removal of Layout Ecto schema
The \Beacon.Layouts.Layout\ Ecto schema has been removed from the codebase. This eliminates the database model that previously managed layout entities, including fields for body content, meta tags, site association, stylesheets, and title.
lib/beacon/layouts · high confidence
Removal of legacy Page, PageVersion, and Component schemas
The legacy Ecto schema definitions for \Beacon.Components.Component\, \Beacon.Pages.Page\, and \Beacon.Pages.PageVersion\ have been removed from the codebase. This deletion eliminates the underlying data models for the previous page and component management system, indicating a structural shift in how content and components are persisted or managed within the Beacon application.
lib/beacon/pages · high confidence
Removal of legacy PageLive module
The \lib/beacon\_web/live/page\_live.ex\ file has been deleted. This removes the previous implementation of the page LiveView, which was responsible for mounting page data, managing layout IDs, and handling page update events via PubSub. This change is part of the broader redesign of resource loading and lifecycle handling.
_lib/beacon\web/live · high confidence
Removal of legacy layout templates
The \live\_dynamic.html.heex\ and \root.html.heex\ template files have been deleted from the \lib/beacon\_web/templates\ directory. This change removes the previous implementation of dynamic and root layouts, which previously handled meta tags, stylesheet inclusions, and script loading via specific helper tags like \stylesheet\_tags\ and \render\_layout\. These templates are no longer part of the application's rendering structure.
_lib/beacon\web/templates · high confidence
Removal of the legacy dynamic module loader subsystem
The \lib/beacon/loader\ directory has been completely removed, eliminating the legacy system that dynamically generated and compiled Elixir modules for components, layouts, and pages at runtime. This change removes the \ComponentModuleLoader\, \LayoutModuleLoader\, \PageModuleLoader\, \ModuleLoader\, \DBLoader\, and \Server\ modules, which previously handled loading these resources from the database and injecting them into the BEAM virtual machine. Users relying on this specific dynamic loading mechanism will need to adopt the new resource loading architecture.
lib/beacon/loader · high confidence
Removed legacy database migrations
The legacy Ecto migration files for creating the \layouts\, \pages\, \components\, and \page\_versions\ tables have been deleted from the repository. This removes the initial schema definitions that were previously used to set up these core data structures in the database.
priv/repo · high confidence
Behavioural changes
Add runtime error layout template
A new layout template for runtime errors has been added to the application. This template provides the standard HTML structure, including CSRF tokens, title, and links to CSS and JavaScript assets, serving as the wrapper for error pages displayed during application failures.
priv/layouts · high confidence
Bundled Tailwind CSS configuration and default Phoenix styles
The \priv\ directory now includes a pre-bundled Tailwind CSS configuration file (\tailwind.config.bundle.js\) and a default stylesheet (\tailwind.css\). The bundled config integrates core Tailwind utilities and plugins (such as \mini-svg-data-uri\) into a single ESM-compatible module, simplifying the build setup. The new default stylesheet provides essential styling for Phoenix-specific UI elements, including alert boxes, form validation feedback, and LiveView interaction states like \phx-click-loading\ and modals, along with standard fade-in/fade-out animations.
priv · high confidence
Database schema overhaul and migration tooling for GraphQL and Collections
This update introduces a comprehensive set of database migrations (v001–v013) that restructure the core data model and add new capabilities. It establishes the initial schema for assets, components, layouts, and pages, then progressively adds support for global event handlers, JS hooks, CSS manifests, and GraphQL endpoints with page queries. The schema expands to include an AST-based template system, detailed SEO fields (Open Graph, Twitter cards, canonical URLs), and content management features like authors, redirects, internal links, and FAQ items. A significant architectural shift replaces the previous template type system with a more flexible Collections model, migrating existing data automatically. To assist with the transition to the new GraphQL data layer, a new \GraphQLMigrator\ tool is provided to analyze sites for legacy data sources and event handlers, offering a dry-run report and cleanup utilities.
lib/beacon/migrations · high confidence
Migrate content loading and cache invalidation to RuntimeRenderer
The system now uses the new \Beacon.RuntimeRenderer\ to manage content, replacing the previous BEAM-module compilation pipeline. Published content is loaded into an ETS store as serializable IR rather than compiled code, with pages loading lazily on first request while the route index is pre-loaded at boot. Cache invalidation is handled by a dedicated \PubSubHandler\ that listens for content changes and updates the ETS store, including optimized CSS recompilation that skips the process if no new Tailwind classes are detected.
_lib/beacon/runtime\renderer · high confidence
New Ecto type definitions for site, atom, binary, and JSON array map validation
The \lib/beacon/types\ directory now includes four new Ecto type modules (\Beacon.Types.Site\, \Beacon.Types.Atom\, \Beacon.Types.Binary\, and \Beacon.Types.JsonArrayMap\) that enforce specific data shapes and validation rules. \Beacon.Types.Site\ ensures site identifiers are valid atoms (stored as strings in the database) and explicitly rejects names starting with \beacon\_\. \Beacon.Types.JsonArrayMap\ validates that JSON data conforms to a list of maps structure, handling conversion between binaries, maps, and lists. These types provide stricter input validation and serialization/deserialization logic for these specific data patterns within the Beacon application.
lib/beacon/types · high confidence
Removal of BeaconWeb module
The \BeaconWeb\ module, which previously served as the central entrypoint for defining web interfaces (controllers, views, live views, components, routers, and channels) via the \use BeaconWeb, :type\ macro, has been removed. This change indicates a shift away from the centralized web module pattern, likely requiring developers to use Phoenix's built-in macros (such as \use Phoenix.Controller\, \use Phoenix.LiveView\, etc.) directly or rely on alternative module definitions within the application.
_lib/beacon\web · high confidence
Removal of legacy layout view helpers
The \DynamicLayoutView\ and \LayoutView\ modules have been removed from the codebase. This change eliminates the previous implementation details for rendering dynamic layouts, page titles, meta tags, and stylesheet tags, indicating a migration away from these specific view-based rendering patterns.
_lib/beacon\web/views · high confidence
Removal of legacy root layout plug
The \BeaconWeb.Plug\ module, which previously used a Plug to manually set the root layout via \Phoenix.Controller.put\_root\_layout\, has been removed. This change reflects a migration away from the older view-based layout system towards the newer layouts and components approach, simplifying the request pipeline by eliminating the now-redundant plug.
_lib/beacon\web/plugs · high confidence
Removal of live\_data callback from data source behaviour
The \Beacon.DataSource.Behaviour\ module has been removed, specifically eliminating the \live\_data/3\ callback that previously allowed data sources to provide live-updating content for a given site, path, and parameters. This change indicates that the live data retrieval mechanism is no longer part of the standard data source interface.
_lib/beacon/data\source · high confidence
Require minimum LiveView v1.0.0
Beacon now requires Phoenix LiveView version 1.0.0 or higher. This is a breaking change that removes support for older LiveView versions, aligning the CMS with the latest LiveView release.
(repo-wide) · high confidence
Updated heroicons to v2.0.16
The vendorized heroicons library has been upgraded to version 2.0.16. This update replaces the existing SVG icon assets in the optimized folder with the latest designs and paths from the upstream library, ensuring that all icon-based UI components reflect the current visual standards.
assets/vendor · high confidence
Test coverage
Add integration tests for Page LiveView; Added comprehensive test suite for Beacon core subsystems; Added lifecycle tests for asset uploads and template rendering; Added placeholder test suite for web components; Added test coverage for Beacon template system components; Added test coverage for content management and SEO features; Added test coverage for web controllers; Added test fixtures for Beacon content entities; Added test migration helper for Beacon tables; Added test support files for Beacon.Web router and configuration; Added test support infrastructure for Beacon integration testing; Added tests for Beacon actions and GraphQL data layer; Added tests for Beacon types; Added tests for BeaconAssigns and Cache modules; Added tests for CSS candidate extraction, manifest validation, and ETS-based storage; Added tests for SEO crawler management, JSON-LD schema generation, and link extraction; Expanded test infrastructure and coverage for media library and web assigns.
Dependencies
Bump minimum Elixir version to 1.14 and update core dependencies
The project now requires Elixir 1.14.1 or 1.15 (previously 1.13) and updates several core dependencies, including Phoenix LiveView (\>= 1.0.1), MDEx (\~\> 0.9), Phoenix HTML (\~\> 4.0), and Phoenix Ecto (\~\> 4.4). Additionally, the minimum OTP version for the esbuild dependency is now conditionally enforced based on the running OTP release.
(dependencies) · 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 → 60 (+2.8)
- Rubric changed (rubric-2026.10.5 → rubric-2026.11.3) — scores are not directly comparable.
Lenses
- Code Health 96 → 94 (-2.1)
- Architecture 85 → 88 (+2.2)
- Maturity 60 → 60 (-0.0)
- Readiness 59 → 65 (+6.0)
- Security 47 → 50 (+3.6)
Resolved (43)
- Duplicated block (10 lines × 35) (lib/heroicons.ex)
- Duplicated block (11 lines × 2) (lib/heroicons.ex)
- Duplicated block (11 lines × 33) (lib/heroicons.ex)
- Duplicated block (11 lines × 7) (lib/heroicons.ex)
- Duplicated block (12 lines × 2) (lib/beacon/content/page_field.ex)
- Duplicated block (1–5 lines × 3) (lib/heroicons.ex)
- Duplicated block (2–5 lines × 205) (lib/heroicons.ex)
- Duplicated block (2–7 lines × 157) (lib/heroicons.ex)
- Duplicated block (5 lines × 13) (lib/heroicons.ex)
- Duplicated block (5 lines × 8) (lib/heroicons.ex)
- Duplicated block (5 lines × 8) (lib/heroicons.ex)
- Duplicated block (6 lines × 11) (lib/heroicons.ex)
- Duplicated block (6 lines × 18) (lib/heroicons.ex)
- Duplicated block (6 lines × 2) (lib/heroicons.ex)
- Duplicated block (6 lines × 25) (lib/heroicons.ex)
- Duplicated block (6 lines × 5) (lib/heroicons.ex)
- Duplicated block (7 lines × 10) (lib/heroicons.ex)
- Duplicated block (7 lines × 14) (lib/heroicons.ex)
- Duplicated block (7 lines × 2) (lib/heroicons.ex)
- Duplicated block (7 lines × 2) (lib/heroicons.ex)
- …and 23 more
New (80)
- Concentrated knowledge decay
- Duplicated block (10 lines × 35) (lib/heroicons.ex)
- Duplicated block (11 lines × 2) (lib/heroicons.ex)
- Duplicated block (11 lines × 33) (lib/heroicons.ex)
- Duplicated block (11 lines × 7) (lib/heroicons.ex)
- Duplicated block (1–5 lines × 3) (lib/heroicons.ex)
- Duplicated block (2–5 lines × 205) (lib/heroicons.ex)
- Duplicated block (2–7 lines × 157) (lib/heroicons.ex)
- Duplicated block (5 lines × 13) (lib/heroicons.ex)
- Duplicated block (5 lines × 8) (lib/heroicons.ex)
- Duplicated block (6 lines × 11) (lib/heroicons.ex)
- Duplicated block (6 lines × 18) (lib/heroicons.ex)
- Duplicated block (6 lines × 25) (lib/heroicons.ex)
- Duplicated block (6 lines × 5) (lib/heroicons.ex)
- Duplicated block (7 lines × 10) (lib/heroicons.ex)
- Duplicated block (7 lines × 14) (lib/heroicons.ex)
- Duplicated block (7 lines × 2) (lib/heroicons.ex)
- Duplicated block (7 lines × 2) (lib/heroicons.ex)
- Duplicated block (7 lines × 4) (lib/heroicons.ex)
- Duplicated block (7 lines × 4) (lib/heroicons.ex)
- …and 60 more
Written by cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.
Survey your own repository
BeaconCMS/beacon 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 13 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 2e7b8c2a3b1f51b4ed1fa7909b49c07311bb2256 — the exact code this score is about.
- Scored under rubric-2026.11.3 — 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.57+preprod-8ebfb01cf4c0.