bartblast/hologram

Hologram is a full-stack web framework that compiles Elixir applications into a client-side JavaScript runtime, enabling server-side logic to execute directly in the browser. It provides a complete development environment featuring an incremental compiler, a custom template engine, and a router, while maintaining strict behavioral parity between the Elixir server and the JavaScript client through extensive consistency testing. The system supports real-time interactions via Server-Sent Events and distributed state synchronization using CRDTs, allowing for seamless client-side navigation and component updates.

86 changes.

This period established the Hologram framework from scratch, implementing the foundational Elixir compiler, server-side template engine, and client-side JavaScript runtime. It focused on porting Erlang and Elixir standard libraries to the browser, building incremental compilation with caching, and creating a comprehensive test suite to ensure parity between the server and client environments.

93 changes.

This period focused on establishing server-side Server-Sent Events (SSE) infrastructure with cluster synchronization and implementing a comprehensive JavaScript ERTS port, including a PCRE2-compatible regex engine and identifier tokenizer. It also introduced client-side JavaScript interop, middleware compilation, and extensive benchmarking to validate performance across the compiler and runtime.

A new JavaScript benchmark suite has been added to the \benchmarks/javascript\ directory to measure the performance of core runtime components. The suite includes benchmarks for the \Interpreter\ (specifically \matchOperator\ and \isStrictlyEqual\ on equal and unequal atoms), the \Renderer\ (\renderDom\ for text nodes, element nodes, and keyed element lists), and \Bitstring\ operations (including \fromText\, map key encoding via hex and base64, and comparisons against Lodash's \isEqual\). It also covers \Vdom.finalizeChildren\ for keyed lists and text byte size calculations using \Blob\ and \TextEncoder\. The benchmarks utilize a custom helper in \support/helpers.mjs\ to report cold and warm execution times.

benchmarks/javascript · high confidence

Users can now run \mix holo.gen.agents\_md\ and \mix holo.gen.claude\_md\ to automatically create or update \AGENTS.md\ and \CLAUDE.md\ files with Hologram AI rules. These new Mix tasks read the \usage-rules.md\ content from the Hologram package and wrap it in specific markers, intelligently replacing existing marked sections or appending new ones if markers are absent.

lib/mix/tasks/holo/gen · high confidence

A new \mix holo\ Mix task has been added, which sets the \HOLOGRAM\_START\ environment variable and delegates to \Mix.Tasks.Phx.Server\. This allows users to start the Phoenix server with Hologram compilation enabled, providing a convenient way to run the application with this specific feature active.

lib/mix/tasks · high confidence

Introduces a new \Hologram.Middleware.Builder\ module that allows modules to declaratively attach middleware at compile time. By using \Hologram.Middleware.Builder\, developers can define middleware targets (either external modules or local functions) which are accumulated and validated during compilation, ensuring that required functions exist before the application runs.

lib/hologram/middleware · high confidence

The library now includes dedicated exception modules to provide clearer error reporting for specific failure scenarios. New types include Hologram.AssetNotFoundError for missing assets, Hologram.CompileError for page or component compilation failures, Hologram.ParamError for invalid page parameters, Hologram.PropError for invalid component props, and Hologram.TemplateSyntaxError for invalid template markup. These changes allow users to catch and handle these distinct error conditions more precisely.

lib/hologram/errors · high confidence

The benchmarks/elixir/support directory now includes fixture files for Elixir benchmarks, specifically a default layout component and a series of page fixtures (page1 through page19, plus page100). These pages exercise various arithmetic, logical, and list operators (such as +, -, \*, /, ++, --, and, or, not, in) to provide standardized test cases for benchmarking operator evaluation performance.

benchmarks/elixir/support · high confidence

A new Last-Writer-Wins (LWW) Conflict-free Replicated Data Type (CRDT) map has been added to the Hologram library. This component enables distributed systems to maintain consistent key-value state across nodes by using timestamps to resolve conflicts, where the most recent write takes precedence. It supports standard map operations such as putting and getting values, merging maps, and computing deltas for synchronization, while handling deletions via tombstones to ensure eventual consistency.

lib/hologram/crdt · high confidence

A new benchmark suite has been added to measure the performance of the \mix compile.hologram\ task. The suite uses Benchee to compare compilation times with and without a cache, providing statistical data on execution speed to help track performance regressions or improvements in the compilation process.

benchmarks/elixir/mix · high confidence

New Elixir and JavaScript scripts have been added to the \scripts/uppercase\_mapping\ directory to generate full Unicode uppercase character mappings (covering codepoints 0 to 0x10FFFF) and compare the results between the two languages. The Elixir script (\generate\_mapping.exs\) uses \:string.titlecase/1\ and the JavaScript script (\generate\_mapping.mjs\) uses \toUpperCase()\ to produce \mapping\_elixir.txt\ and \mapping\_javascript.txt\ respectively. A third script, \compare\_mappings.exs\, analyzes these files to detect inconsistencies, identifying 2,210 differences in the current output and writing a detailed report to \comparison.txt\.

_scripts/uppercase\mapping · high confidence

New scripts in the \scripts/regex\_case\_folding\ directory provide a toolchain to maintain accurate Unicode case folding for the regex engine. The \folding\_oracle.mjs\ module builds a map of true case-folding equivalence classes using JavaScript's \/iu\ regex semantics as the ground truth. The \generate\_overrides.mjs\ script identifies code points where naive case mapping differs from the true folding classes and outputs the necessary override data. The \verify\_overrides.mjs\ script validates that the regex engine's \caseVariants\ function matches the oracle for all code points, ensuring consistency between the engine's behavior and standard Unicode case folding.

_scripts/regex\_case\folding · high confidence

Initializes the Hologram framework repository with essential configuration files and documentation. This includes setting up the \.check.exs\ file to orchestrate the CI/CD pipeline with tools like Credo, Dialyzer, Sobelow, and Prettier, alongside dedicated configs for Credo (\.credo.exs\), Doctor (\.doctor.exs\), Recode (\.recode.exs\), and Prettier (\.prettierignore\). Development workflows are supported by \lefthook.yml\ for pre-commit hooks and \.tool-versions\ to pin Elixir, Erlang, and Node.js versions. The repository also introduces standard governance and contribution documents, including \LICENSE\ (Apache 2.0), \SECURITY.md\ (private vulnerability reporting), \CONTRIBUTING.md\ (issue-based contribution model), and \llms.txt\/\llms-full.txt\ for LLM documentation indexing.

(repo-wide) · high confidence

Added a suite of scripts and generated data tables in the identifier tokenizer directory to support the JavaScript port of the BEAM's identifier classification. The new files include \generate\_classes.exs\ and \generate\_classes.mjs\ to produce oracle classification data for Elixir and JavaScript respectively, \generate\_scriptsets.exs\ and \generate\_scriptsets.mjs\ to derive script signatures, and \generate\_table.mjs\ to build the compact identifier class table embedded in the runtime's \string/tokenizer.mjs\. Supporting scripts \compare\_classes.exs\ and \compare\_scriptsets.exs\ allow verification of consistency between the BEAM and JavaScript classifications, while \generate\_verification.exs\ and \verify\_tokenizer.mjs\ provide a corpus-based validation layer for the tokenizer implementation.

_scripts/identifier\tokenizer · high confidence

The application now includes a standard Elixir configuration setup with \config/config.exs\, \config/dev.exs\, and \config/test.exs\. These files define default debug flags (\debug\_encoder\, \debug\_parser\, \debug\_transformer\) for the \:hologram\ application and configure the Logger level to \:warning\ in the test environment, while importing environment-specific configurations.

config · high confidence

This change adds the foundational JavaScript client runtime for the Hologram framework, replacing the previous Phoenix-based client. It introduces the main entry point (App class) for bootstrapping the application and managing instance IDs, alongside a new AssetPathRegistry for resolving static assets. The diff also includes a comprehensive Bitstring implementation for structural comparison and manipulation consistent with Elixir's behavior, and an ERTS (Erlang Runtime System) class to provide manually ported Erlang/Elixir standard library functions (such as maps, strings, and lists) and utilities like UTF-8 encoding/decoding. These components form the core infrastructure required for the new client-side interpreter, serializer, and DOM rendering capabilities.

assets/js · high confidence

Added a new set of utility modules to the Hologram.Commons library to provide cross-platform and helper functionality. This includes Hologram.Commons.ETS for managing Erlang Term Storage tables with concurrency options, Hologram.Commons.PLT for a persistent lookup table backed by ETS and GenServer, and Hologram.Commons.FileUtils for file operations like atomic writes and recursive listing. Additional modules cover string manipulation (StringUtils), path handling (PathUtils), system commands (SystemUtils), cryptographic hashing (CryptographicUtils), and concurrent task mapping (TaskUtils).

lib/hologram/commons · high confidence

The Hologram framework now includes a client-side runtime and a Link component to handle page navigation and hydration. The new UI.Runtime component injects essential initialization data (such as CSRF tokens, instance IDs, and asset manifests) into the global scope and loads the necessary JavaScript bundles for the current page and the core runtime. The UI.Link component provides a declarative way to create navigation links that support prefetching and explicit click handling, enabling smoother client-side page transitions.

lib/hologram/ui · high confidence

Adds a new client-side JavaScript interop layer (js.mjs) that enables Elixir code to interact with the browser environment. This implementation provides functions for calling JS methods, getting/setting properties, executing arbitrary JS code, handling events, and managing type conversions between Elixir terms and JavaScript values, including safe handling of map keys and nullish bindings.

assets/js/elixir/hologram · high confidence

This change adds the core server-side components for the new Server-Sent Events (SSE) realtime system. It introduces a Subscription Registry to track client bindings and handle identity-based authorization, a Handshake stash to securely store and redeem session tokens across the cluster, and a Tombstone store to manage subscription revocations with a 72-hour retention window. These components are wired together with a Gossip module that enables boot-time state synchronization and steady-state replication between cluster nodes, ensuring consistent subscription state even during node joins or restarts.

lib/hologram/realtime · high confidence

A new generator module has been added to manage AI rules files (such as AGENTS.md or CLAUDE.md). This tool syncs content from the Hologram dependency's usage-rules.md into a target file, wrapping the rules in specific markers (hologram-start/hologram-end) to allow for safe updates. It handles both creating new files and updating existing ones by either replacing the marked section or appending the rules if no markers are present.

lib/hologram/generators · high confidence

The ERTS runtime in the browser now includes several new internal components to support advanced Erlang/Elixir features. A shadow call stack tracks Elixir-level frames to provide accurate stacktraces despite JavaScript minification and async boundaries. Application environment storage allows reading and writing app configuration via a nested map structure. Several registries manage runtime state: a node table handles node incarnation IDs and reverse lookups for clustering, while binary, regex, native object, and promise registries cache compiled patterns, native objects, and async promises respectively for efficient retrieval.

assets/js/erts · high confidence

A new automated benchmark runner (benchmarks/elixir/run\_all.exs) has been added to execute and aggregate performance tests for the Elixir compiler. This runner discovers and executes individual Benchee suites—such as build\_module\_info\_plt, build\_module\_metadata, and validate\_page\_modules—and writes the consolidated results to benchmarks/elixir/README.md. The suite provides detailed performance metrics (IPS, average time, deviation) for key compiler operations, allowing developers to track regressions in module info PLT building, metadata construction, and page module validation.

benchmarks/elixir · high confidence

The Hologram framework now includes a dedicated Application module that starts a supervisor tree containing core services such as PubSub, the page module resolver, asset registries, and the realtime handshake and subscription components. This is accompanied by the introduction of the Compiler module for building call graphs and IR, the Component module defining the component behavior and action/command structs, the Controller for handling page requests and cookie operations, and the Framework module which defines the Elixir standard library module groups used for compilation. These files establish the foundational runtime and compilation infrastructure for the framework.

lib/hologram · high confidence

The JavaScript ERTS now includes a dedicated regex engine that emulates PCRE2 semantics, replacing the previous native JavaScript RegExp behavior for complex patterns. This engine supports advanced features such as variable-length lookbehinds, atomic groups, backtracking control verbs, and Unicode case folding, while maintaining compatibility with POSIX character classes and shorthand escapes. When a pattern can be safely translated to native JavaScript RegExp, the engine uses it for performance; otherwise, it falls back to a custom interpreter to ensure correct PCRE2 behavior.

assets/js/erts/regex · high confidence

A new Sequence class has been added to the common JavaScript utilities, providing a simple mechanism to manage incrementing integer values. Users can now instantiate this class to generate sequential numbers via the next() method and reset the counter to zero using the reset() method, facilitating state management for features requiring ordered sequences.

assets/js/common · high confidence

The \assets/js/events\ directory now includes a comprehensive set of new event handler classes (ChangeEvent, ClickEvent, ClickOutsideEvent, FocusEvent, InputEvent, KeyboardEvent, MouseEvent, PointerEvent, ReachEvent, ResizeEvent, ScrollEvent, SelectEvent, SubmitEvent, and TransitionEvent) that define how browser events are captured, filtered, and serialized for the framework. These classes establish the data payloads sent to the server—for example, SubmitEvent now extracts form data with specific handling for checkboxes, while KeyboardEvent exposes modifier keys and key codes—and set default behaviors, such as allowing native browser actions for most pointer and keyboard events while preventing them for form submissions.

assets/js/events · high confidence

Added four new Mix tasks under the \holo.compiler\ namespace to help developers inspect and optimize the Hologram compiler's output. \mix holo.compiler.ex\_runtime\_mfas\ lists the automatically transpiled Elixir functions used by the client runtime. \mix holo.compiler.page\_ex\_fun\_sizes\ calculates and displays the JavaScript size impact of each Elixir function included in a specific page module bundle, sorted by size. \mix holo.compiler.page\_to\_mfa\_paths\ and \mix holo.compiler.runtime\_to\_mfa\_paths\ print the shortest call-graph paths from page or runtime entry points to a specified destination MFA, aiding in debugging dependency chains and understanding code inclusion.

lib/mix/tasks/holo/compiler · high confidence

The router now includes a new \Hologram.Router.Helpers\ module providing \asset\_path/1\ to resolve static asset URLs with digests (raising if not found), \page\_bundle\_path/2\ to generate JavaScript bundle paths, and \page\_path/1\ and \page\_path/2\ to build relative URLs for pages, supporting both keyword lists and maps of parameters with proper URI encoding. Additionally, a new \Hologram.Router.PageModuleResolver\ GenServer loads page routes from the compiler's PLT dump into a persistent term for efficient lookup, and a new \Hologram.Router.SearchTree\ module implements the underlying trie structure for adding and matching URL routes.

lib/hologram/router · high confidence

This change introduces JavaScript implementations for several core Elixir modules, enabling their use in the client-side interpreter. The new files provide \Elixir\_Application.get\_env/3\ for reading application configuration, \Elixir\_Code.ensure\_compiled/1\ and \ensure\_loaded/1\ for module loading checks, and \Elixir\_IO\ functions (\inspect\, \warn\, \warn\_once\) for console output and warnings. String manipulation is supported via \Elixir\_String\ (including \contains?\, \downcase\, \upcase\, \replace\, and \trim\), while \Elixir\_URI.encode/2\ handles URL encoding. Additionally, \Elixir\_Task.await/1\ allows waiting for promises, \Elixir\_Kernel.inspect/1\ and \2\ provide term inspection, and \Elixir\_Exception.format\_stacktrace/1\ along with \Elixir\_FunctionClauseError\ handle error rendering and function clause mismatch reporting on the client.

assets/js/elixir · high confidence

The \assets/js/erlang\ directory now contains JavaScript implementations of core Erlang modules, including \erlang\, \binary\, \lists\, \maps\, \sets\, \string\, \filename\, \code\, \application\, and \elixir\_aliases\. This change brings a significant portion of the Erlang standard library to the client-side runtime, allowing functions like \:erlang.is\_atom/1\, \:lists.map/2\, and \:binary.split/2\ to execute directly in the browser. The implementation includes error handling that mirrors the BEAM's behavior, such as raising \FunctionClauseError\ or \badarg\ with specific error info, and aligns certain behaviors with Erlang/OTP 28 (e.g., string titlecase).

assets/js/erlang · high confidence

A new standalone session management module has been introduced to handle session initialization, encryption, and cookie management independently. This module provides functionality to create new session IDs, encrypt and decrypt session data using a derived key, and manage secure HTTP-only cookies with appropriate SameSite and Secure attributes based on the connection scheme.

lib/hologram/runtime/session · high confidence

The assets directory now uses a modern ESLint flat configuration (eslint.config.mjs) and Prettier to enforce consistent code style. The new ESLint setup explicitly declares globals for Elixir and Erlang modules (such as Elixir\_Code, Erlang\_Filename, etc.) to prevent false-positive linting errors in the JavaScript layer that interfaces with the BEAM runtime. It also excludes vendored third-party code from linting to preserve byte-identical upstream files and configures Prettier with bracketSpacing disabled. This change improves developer experience by providing stricter, more accurate linting rules and automated formatting for the asset codebase.

assets · high confidence

The Hologram compiler now uses incremental compilation to rebuild only the pages and bundles affected by code changes, significantly speeding up development feedback loops. It also introduces a new \mix holo.routes\ task to list all defined page routes, and adds compiler locking to prevent concurrent compilation issues.

lib/mix/tasks/compile · high confidence

The runtime logic has been reorganized into the new Hologram.Runtime namespace, introducing dedicated modules for connection handling, cookie management, CSRF protection, and client-to-server deserialization. The new Hologram.Runtime.Connection module manages WebSocket interactions and message decoding, while Hologram.Runtime.Session provides helpers to mint and retrieve session IDs and authenticated user IDs from the Phoenix session. Hologram.Runtime.Deserializer handles the conversion of client-side data (including references, atoms, and functions) into safe Elixir terms, and Hologram.Runtime.CSRFProtection ensures token generation and validation align with Plug standards. These changes establish the core runtime infrastructure for handling client connections and state.

lib/hologram/runtime · high confidence

The asset handling infrastructure has been restructured into a modular system under the \Hologram.Assets\ namespace, introducing three new GenServer-based components: \PathRegistry\ for mapping static file paths to their digested asset URLs (supporting both MD5 and esbuild content hashes), \ManifestCache\ for storing and serving the JavaScript asset manifest via persistent terms, and \PageDigestRegistry\ for tracking page module digests using ETS tables. This change adds the capability to reload these registries at runtime, filters out source maps from the asset mapping, and ensures the generated manifest JavaScript is safely encoded to prevent injection issues when embedded in HTML scripts.

lib/hologram/assets · high confidence

The compiler now persists compilation state between runs via a new \Hologram.Compiler.Cache\ GenServer. This cache retains the call graph, IR PLT, module info PLT, and bundle metadata (such as page states and runtime MFAs) in memory and on disk. By keeping this state, subsequent compiles can patch the IR PLT and call graph with module digest diffs, allowing the compiler to rebuild only the specific functions and pages affected by code changes rather than performing a full rebuild. This significantly improves compile times during development and live-reload scenarios.

lib/hologram/compiler · high confidence

The template rendering system has been replaced with a new implementation located in lib/hologram/template. This new engine introduces a dedicated tokenizer (Tokenizer), a state-machine parser (Parser), and a server-side renderer (Renderer) that builds a DOM AST (DOM) and outputs HTML. It supports a new template syntax using single curly braces for interpolation (e.g., ${expression}), handles event modifiers (debounce, throttle, key filters) via a new EventModifiers module, and includes helpers for tag normalization and void element detection. The new system also supports public comments, DOCTYPE declarations, and dynamic tags, replacing the previous template handling logic.

lib/hologram/template · high confidence

The server module now supports structured broadcasts via a new \Broadcast\ struct that allows sending messages to specific channels while excluding certain identities. Server state is enriched with a \Metadata\ struct to track cookie operations, session operations, and subscription changes. A new \Middleware\ module provides a runner that executes a chain of middleware functions, allowing them to modify the server state or terminate the chain early. Additionally, a \Status\ module maps symbolic HTTP status aliases to their numeric codes.

lib/hologram/server · high confidence

The library now provides a central \Hologram\ module to manage runtime behavior, replacing the previous \Reflex\ module. This new module exposes functions to check if the runtime is enabled (controlled by the \HOLOGRAM\_START\ environment variable in dev/test), detect the current environment, and resolve the \SECRET\_KEY\_BASE\ (falling back to the Phoenix endpoint configuration in dev/test). It also introduces compile-time configuration options for client-side diagnostics: \client\_stacktraces\ (defaulting to true in dev/test) and \client\_error\_overlay\ (defaulting to the stacktrace setting), allowing developers to control whether uncaught client errors are displayed in the browser page versus only logged to the console.

lib · high confidence

The JavaScript Cldr module now includes stub implementations for \Cldr.Locale.language\_data/0\ and \Cldr.Validity.U.encode\_key/2\. These functions currently throw a specific interpreter error indicating that the output is too large to be manually ported, serving as temporary placeholders until a proper implementation is available.

assets/js/elixir/cldr · high confidence

The Hologram router helper functions, specifically \asset\_path/1\, have been ported from Erlang to JavaScript. This new \helpers.mjs\ module provides the \asset\_path/1\ function, which looks up static assets via the \AssetPathRegistry\ and raises a \Hologram.AssetNotFoundError\ if the asset is not found. This change moves the implementation of these routing helpers into the client-side JavaScript runtime.

assets/js/elixir/hologram/router · high confidence

The JavaScript identifier tokenizer has been replaced with a manual port of Elixir's BEAM implementation to ensure client-side parsing matches the server exactly. This change replaces large, generated UTS 39 guard clauses with a compact, encoded range table and native browser Unicode properties, significantly reducing bundle size while maintaining strict compliance with Elixir's identifier rules. The new tokenizer correctly handles mixed-script errors, atom rendering, and edge cases like the micro sign normalization across the full Unicode spectrum.

assets/js/elixir/string · high confidence

The error handling system in the client-side JavaScript runtime has been restructured to improve how errors are captured, normalized, and displayed. A new \HologramBoxedError\ class now wraps runtime errors, capturing a snapshot of the call stack at the moment of failure and carrying internal fields (kind, value, struct, blamedStruct) as non-enumerable properties to ensure compatibility with browser error reporting. This class normalizes bare error reasons into exception structs and derives display messages through a 'blame pipeline' that refines the error against the stacktrace. To prevent infinite recursion during error derivation, a static flag prevents re-deriving an error while it is already being processed. Additionally, two new specific error classes, \HologramInterpreterError\ and \HologramRuntimeError\, have been introduced to distinguish between interpreter-level faults and general runtime errors, replacing the previous generic boxed error usage.

assets/js/errors · high confidence

The realtime SSE stream now correctly detects when a client disconnects across different web servers, preventing streams from hanging indefinitely. This is achieved by introducing an adapter pattern (\Hologram.Realtime.SSE.Adapter\) that abstracts server-specific connection termination signals. For Bandit, the new \Bandit\ adapter handles HTTP/2 stream resets and arms HTTP/1.1 socket monitoring to detect closed connections immediately, rather than waiting for a heartbeat failure. A \Passive\ adapter is also provided for servers like Cowboy that terminate the stream process automatically, ensuring the system works seamlessly regardless of the underlying server implementation.

lib/hologram/realtime/sse · high confidence

A new module in the live reload subsystem parses raw Elixir compiler output into structured, tone-tagged segments (banner, body, chrome, meta). This allows the frontend error overlays to render diagnostic messages with consistent styling and separation of concerns, ensuring that stack frames and source locations are displayed correctly even if the compiler's output format changes slightly.

_lib/hologram/live\reload · high confidence

The benchmark suite in benchmarks/elixir/reflection has been recalibrated and re-run, updating the performance baselines for Hologram.Reflection functions including module?, elixir\_module?, erlang\_module?, has\_function?, has\_struct?, list\_components/, list\_elixir\_modules/, and list\_pages/. These new results, generated on macOS with Elixir 1.20.0 and Erlang 29.0.1, reflect the current execution times for these reflection operations.

benchmarks/elixir/reflection · high confidence

The benchmark suite for the PLT dump functionality has been recalibrated to reflect recent API changes. The new test configuration in benchmarks/elixir/commons/plt/dump\_2 measures the performance of Hologram.Commons.PLT.dump/2 using an IR PLT generated via Compiler.build\_ir\_plt(). This update ensures that benchmark results accurately represent the current behavior of the PLT dumping process following the removal of unused IR PLT and call graph dump loaders.

benchmarks/elixir/commons · high confidence

The benchmark suite for the compiler's call graph has been refreshed with new and updated test cases for several key operations. This includes benchmarks for cloning the graph, dumping it to disk, and patching it with module changes (added, removed, or edited). Additional benchmarks now cover listing modules reaching specific targets, listing page and runtime MFAs, removing manually ported and runtime MFAs, removing graph vertices, and analyzing server callbacks and protocol dispatch types. These updates reflect recent changes to the compiler's internal APIs and provide current performance baselines for these core compiler functions.

_benchmarks/elixir/compiler/call\graph · high confidence

The compiler benchmarks for \build\_page\_js/5\ and \encode\_reachable\_functions/5\ have been refreshed to align with the new async MFAs API. The benchmark setup now explicitly computes and passes \async\_mfas\ (derived from the call graph) and \module\_info\_plt\ to the compiler functions, ensuring the performance measurements reflect the current signature and behavior of the Hologram compiler.

_benchmarks/elixir/compiler/build\_page\_js\5 · high confidence

Add benchmark for Hologram.Compiler.create\_page\_entry\_files/6; Added App 3 page and layout for testing sibling library serving; Added Elixir consistency tests for Erlang/OTP modules; Added Elixir consistency tests for core standard library functions; Added Elixir-JavaScript consistency tests for core language features; Added Hologram.Test.FeatureHelpers for shared browser test utilities; Added JavaScript consistency tests for Elixir standard library modules; Added JavaScript fixture for Module7 test scenario; Added JavaScript test fixtures for Erlang and Interpreter consistency; Added JavaScript unit tests for App, AssetPathRegistry, and Bitstring modules; Added benchmark for Hologram.Compiler.Encoder.encode\_term!/1 scaling; Added benchmark for Hologram.Compiler.build\_call\_graph/1; Added benchmark for IR PLT patching and filling; Added benchmark suite for Hologram.Compiler.bundle/2; Added browser and tooling tests for the umbrella app\_1; Added client-side renderer test fixtures; Added cluster integration tests for distributed node behavior and proxy routing; Added cluster test application scaffolding; Added compiler PLT benchmark suites; Added comprehensive test coverage for Hologram Commons utilities; Added comprehensive test coverage for the Hologram compiler; Added comprehensive test suite for Hologram template engine; Added comprehensive test suites for Hologram core modules; Added comprehensive tests for the Hologram compile Mix task; Added consistency tests for the Elixir String tokenizer; Added end-to-end test scaffolding for Hologram umbrella projects; Added feature test pages for app pages; Added feature test pages for event bindings; Added feature test pages for routing scenarios; Added feature test support infrastructure; Added feature tests for HTML patching behavior; Added feature tests for call graph traversal scenarios; Added feature tests for component prop rendering and validation; Added feature tests for control flow constructs; Added feature tests for cookie operations; Added feature tests for element-level and form-level change events; Added feature tests for event default prevention; Added feature tests for function call behaviors; Added feature tests for function call scenarios; Added feature tests for layout page configurations; Added feature tests for middleware composition and navigation scenarios; Added feature tests for page templates defined in files and functions; Added feature tests for realtime component subscriptions and broadcasts; Added feature tests for rendering pages and component props; Added feature tests for session management in page contexts; Added feature tests for template syntax edge cases; Added feature tests for the live reload pages; Added integration tests for the Cowboy adapter; Added layout component fixtures for feature tests; Added layout fixture for testing Elixir function definitions; Added navigation test fixtures; Added reflection test fixtures; Added router helper test fixtures; Added router test fixtures for page and component routing; Added test assets for HTTPS feature testing; Added test component for sibling identity across branch switches; Added test configuration for the umbrella end-to-end testing environment; Added test coverage for ERTS core modules; Added test coverage for Hologram Realtime subsystems; Added test coverage for reach event firing in nested components; Added test coverage for the JavaScript ERTS regex engine; Added test coverage for the app\_2 umbrella child application; Added test environment configuration for the cluster test application; Added test fixture for Elixir IR compilation; Added test fixture for Module2 connection page; Added test fixture for SSE adapter behavior; Added test fixtures for Elixir/JS consistency validation; Added test fixtures for Holo compiler mix tasks; Added test fixtures for Hologram compile task; Added test fixtures for UI Link component; Added test fixtures for component action scenarios; Added test fixtures for component operations; Added test fixtures for component templates and state management; Added test fixtures for feature tests; Added test fixtures for js\_import macro; Added test fixtures for layout and Phoenix endpoint testing; Added test fixtures for live reload scenarios; Added test fixtures for map utilities and file listing; Added test fixtures for middleware builder and module composition; Added test fixtures for middleware composition; Added test fixtures for normalizing special function names; Added test fixtures for page routing, layouts, and template aliases; Added test for file name validation in Holo test tasks; Added test for security component props; Added test helper module for Phoenix controller setup; Added test helpers and assertions for JavaScript runtime error handling; Added test infrastructure for Hologram feature tests; Added test infrastructure for feature tests; Added test pages for event debounce scenarios; Added test pages for event throttling feature; Added tests for CRDT Map implementation; Added tests for Elixir Cldr.Locale and Cldr.Validity.U modules; Added tests for Hologram router helpers and page module resolver; Added tests for Hologram.Generators.AIRules.sync/2; Added tests for HologramBoxedError and HologramInterpreterError classes; Added tests for SSE adapter client disconnection handling; Added tests for UI Link component and Runtime behavior; Added tests for holo.gen.agents\_md and holo.gen.claude\_md tasks; Added tests for live reload diagnostic parsing; Added tests for middleware builder compilation; Added tests for middleware execution and status code resolution; Added tests for session initialization logic; Added tests for split-module JS import behavior; Added tests for the Holo routes mix task; Added tests for the Sequence class; Added tests for the mix holo task; Added unit tests for Elixir Hologram Router Helpers; Added unit tests for Holo compiler Mix tasks; Added unit tests for Hologram JS interop boxing and unboxing; Added unit tests for Hologram runtime components; Added unit tests for JavaScript event handling classes; Added unit tests for asset management modules; Added verification script for client-side atom inspection fast path; Comprehensive feature tests for event bindings and modifiers; Expanded JavaScript interop feature tests; Expanded compiler test fixtures for Elixir components and pages; Expanded end-to-end feature test coverage for Hologram runtime capabilities; Expanded feature tests for page actions; Expanded realtime feature test fixtures; Expanded test fixtures for compiler call graph analysis; Expanded test fixtures for controller and component behavior; Expanded test fixtures for template and renderer scenarios; Expanded transformer test coverage for Elixir language constructs; Initial Elixir test suite setup; New test infrastructure and helpers for Elixir tests; New test infrastructure for validating cluster behavior; Removed legacy unit tests and test configuration; Test environment configuration for feature tests; Updated router helper fixtures to use new Type API.

The project now includes a dedicated \assets\ directory with a \package.json\ and \package-lock.json\ to manage JavaScript dependencies. This setup installs esbuild for bundling, Snabbdom and Lodash for runtime support, and a suite of development tools including ESLint, Prettier, Mocha, Chai, Sinon, and JSDOM for testing. This change establishes the foundation for client-side JavaScript compilation and testing within the Hologram ecosystem.

(dependencies) · high confidence

The vendored Snabbdom library in assets/js/vendor/snabbdom has been updated to version 3.6.4. The update includes the removal of source maps and type declarations to reduce bundle size, while the JavaScript build files remain byte-identical to the upstream npm package. This change ensures the library is kept up-to-date with the latest release without introducing custom deviations.

assets/js/vendor · high confidence

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

• CAI 55 → 59 (+4.1)
• Rubric changed (rubric-2026.08.19 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 48 → 48 (+0.5)
• Architecture 61 → 75 (+13.9)
• Maturity 57 → 60 (+2.8)
• Readiness 75 → 75 (-0.1)
• Security 70 → 94 (+23.9)

• #asyncWalkComprehension (cognitive 17) (assets/js/interpreter.mjs)
• #calculateBranchLengthRange (cyclomatic 36) (assets/js/erts/regex/regex_parser.mjs)
• #classItemsMatch (cognitive 19) (assets/js/erts/regex/regex_interpreter.mjs)
• #collectDefiniteGroups (cyclomatic 16) (assets/js/erts/regex/regex_analyzer.mjs)
• #compareLists (cognitive 18) (assets/js/interpreter.mjs)
• #fromSegmentWithIntegerOutsideNumberRangeValue (cyclomatic 17) (assets/js/bitstring.mjs)
• #fromSegmentWithIntegerWithinNumberRangeValue (cyclomatic 17) (assets/js/bitstring.mjs)
• #hasUnresolvedVariablePattern (cognitive 16) (assets/js/interpreter.mjs)
• #hasUnresolvedVariablePattern (cyclomatic 18) (assets/js/interpreter.mjs)
• #matchAnchor (cyclomatic 21) (assets/js/erts/regex/regex_interpreter.mjs)
• #matchBitstringPattern (cyclomatic 22) (assets/js/interpreter.mjs)
• #matchNodeDispatch (cognitive 55) (assets/js/erts/regex/regex_interpreter.mjs)
• #matchNodeDispatch (cyclomatic 51) (assets/js/erts/regex/regex_interpreter.mjs)
• #matchVerb (cognitive 22) (assets/js/erts/regex/regex_interpreter.mjs)
• #matchVerb (cyclomatic 18) (assets/js/erts/regex/regex_interpreter.mjs)
• #parseCharacterClass (cyclomatic 22) (assets/js/erts/regex/regex_parser.mjs)
• #parseConcatenation (cyclomatic 23) (assets/js/erts/regex/regex_parser.mjs)
• #parseCondition (cognitive 30) (assets/js/erts/regex/regex_parser.mjs)
• #parseCondition (cyclomatic 28) (assets/js/erts/regex/regex_parser.mjs)
• #parseEscape (cyclomatic 16) (assets/js/erts/regex/regex_parser.mjs)
• …and 94 more

• #buildElixirFunction (cognitive 18) (assets/js/interpreter.mjs)
• Bitstring.#fromSegmentWithIntegerOutsideNumberRangeValue (cyclomatic 17) (assets/js/bitstring.mjs)
• Bitstring.#fromSegmentWithIntegerWithinNumberRangeValue (cyclomatic 17) (assets/js/bitstring.mjs)
• Bitstring.compare (cognitive 91) (assets/js/bitstring.mjs)
• Bitstring.compare (cyclomatic 43) (assets/js/bitstring.mjs)
• Bitstring.isPrintableCodePoint (cyclomatic 18) (assets/js/bitstring.mjs)
• ClassTooLong: Bitstring (assets/js/bitstring.mjs)
• ClassTooLong: Hologram (assets/js/hologram.mjs)
• ClassTooLong: Interpreter (assets/js/interpreter.mjs)
• ClassTooLong: Renderer (assets/js/renderer.mjs)
• ClassTooLong: ThenSignal (assets/js/erts/regex/regex_interpreter.mjs)
• Coverage not measured — JavaScript/TypeScript suite
• Dependency advisory scan runs only on code events
• Documentation: contradicts the code (benchmarks/elixir/reflection/module_1/README.md)
• Documentation: no installation or build instructions (README.md)
• Documentation: no project overview (README.md)
• Duplicated block (10 lines × 3) (lib/hologram/compiler/encoder.ex)
• Duplicated block (10–11 lines × 2) (lib/hologram/framework.ex)
• Duplicated block (14 lines × 2) (lib/hologram/compiler/call_graph.ex)
• Duplicated block (14 lines × 2) (lib/hologram/realtime/subscription_registry.ex)
• …and 1994 more

• 300 commits — 299 feature/other, 1 fixes

• lib/hologram — 119 commits
• test/umbrella — 39 commits
• test/elixir — 34 commits
• (repo) — 23 commits
• lib/mix — 22 commits
• benchmarks/elixir — 21 commits
• test/features — 13 commits
• assets/js — 9 commits
• test/cowboy — 8 commits
• .github/workflows — 5 commits
• test/cluster — 3 commits
• (root) — 2 commits
• assets/package-lock.json — 1 commit
• test/javascript — 1 commit

• fix: Merge pull request #1274 (Cut the fixed cost of a compile)
• change: Expose the client config the runtime bundle carries
• change: Add a benchmark for the reverse module walk
• change: Add a listing of the apps a save can recompile
• change: Add a test app covering the Cowboy adapter
• change: Add an adapter seam for how a realtime stream learns its client left
• change: Add an atomic file write
• change: Add benchmarks for patching and filling the IR PLT
• change: Add live reload feature tests
• change: Aggregate JS imports from the module info PLT
• change: Answer a module's implemented protocol from the module info PLT
• change: Answer the protocol and JS import questions from the module info PLT
• change: Benchmark encoding the reachable functions of all pages
• change: Bound the reflection walk from init/3 by the types it names
• change: Build only the missing IR and drop the unread IR
• change: Build page bundle paths from the page module on the client
• change: Build the IR of the modules the call graph walk asks for
• change: Build the bundle benchmark's entry files like the compile task
• change: Build the module metadata once and give it to the renderers
• change: Build the page bundles in batches the caller orders
• …and 280 more

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

bartblast/hologram 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.