Skip to content
CAI
Software that uses CAICheck a score

marko-js/marko

51.1

Adequate · 15 November 2026

58k

lines of production code

TypeScript

with JavaScript

5

measurements over time

CAI band scale
CAI trend line
CAI lens gauges

What this system is

Features

Add TypeScript type stubs for runtime tags

Added \.d.marko\ type definition files for core runtime tags including \await\, \const\, \debug\, \define\, \effect\, \html-comment\, \html-script\, \html-style\, \id\, \let\, \lifecycle\, \log\, \script\, \show\, and \try\. These stubs provide explicit TypeScript interfaces for tag inputs and return types, enabling better type checking and autocomplete for users of these tags in Marko templates.

packages/runtime-tags/tags · high confidence

Compiler error reporting and agent integration utilities

This change introduces a suite of utility modules in the compiler to enhance error diagnostics and coding agent support. It adds a custom CompileError class that generates structured code frames with windowing for long lines, ensuring readable output in both Node.js and browser environments. It also implements an agent-fix-guide mechanism that automatically appends a link to a translator's cheat sheet to compile errors when detected coding agents (like Cursor or Claude Code) are present, helping them resolve issues more effectively. Additionally, it provides utilities for merging multiple compilation errors into a single aggregate error, hashing source content, stripping ANSI codes from output, and safely loading external translators with caching.

packages/compiler/src/util · high confidence

Compiler package structure and API documentation

The \@marko/compiler\ package now includes a comprehensive README and an AGENTS.md guide that document the public API, configuration options, and translator contract. The package exports type definitions for compile results, taglib definitions, and babel-utils, ensuring that tooling and bundler integrations have accurate TypeScript support for the compiler's interface.

packages/compiler · high confidence

Introduce Class API translator for Marko templates

The \packages/runtime-class/src/translator\ directory now contains the complete implementation of the Class API translator, which compiles Marko templates into JavaScript using the Class API. This includes dedicated translators for HTML and VDOM output modes, handling of native and custom tags, dynamic tags, attribute directives (such as \class\, \style\, and \no-update\), and interop logic for the Tags API. Users benefit from a new compilation path that supports class-based component definitions and improved handling of template features like conditional comments, CDATA, and scriptlets.

packages/runtime-class/src/translator · high confidence

Introduce debug and production accessor constant modules

The runtime-tags package now exposes dedicated constant modules for accessor prefixes, property names, and resume symbols, each provided in both debug (human-readable strings) and production (shortened single-character or compact codes) variants. This change introduces new files such as \accessor-prefix.debug.ts\, \accessor-prop.debug.ts\, \resume-symbol.ts\, and \walk-code.ts\ alongside their production counterparts, enabling the runtime to use readable identifiers during development while minimizing bundle size and overhead in production builds.

packages/runtime-tags/src/common/constants · high confidence

Introduce new runtime-class vdom implementation

The runtime-class package now includes a new virtual DOM (vdom) implementation located in src/runtime/vdom. This adds core virtual node types (VElement, VText, VComment, VComponent, VFragment, VDocumentFragment), an AsyncVDOMBuilder for rendering, and a morphdom-based diffing engine to update the DOM. It also provides DOM insertion helpers (appendTo, replace, etc.) and a hot-reload mechanism for class components that detects lifecycle changes and triggers re-renders.

packages/runtime-class/src/runtime/vdom · high confidence

Introduces new HTML runtime implementation for Marko templates

The HTML rendering engine in the runtime-class package has been replaced with a new implementation. This update introduces dedicated modules for managing output streams, including AsyncStream for handling asynchronous rendering, BufferedWriter to optimize write operations by batching chunks, and StringWriter for managing string-based content and script injection. The change also adds support for hot-reloading templates and establishes a global Marko namespace, fundamentally altering how template output is generated and streamed to the client.

packages/runtime-class/src/runtime/html · high confidence

Introduction of new runtime class-based component architecture

The runtime component system has been refactored to support a new class-based component model alongside the existing legacy widget system. This change introduces new core runtime modules including \Component.js\ and \ComponentDef.js\ for managing component instances and metadata, \ServerComponent.js\ for server-side rendering lifecycles, and \State.js\ for tracking state changes. It also adds \ComponentsContext.js\ and \GlobalComponentsContext.js\ to manage rendering contexts and component lookups, while \defineComponent.js\ provides the factory for creating new class-based components. The legacy widget definitions (\defineWidget-legacy.js\, \defineRenderer-legacy.js\) and their associated dependency patching logic remain in place to ensure backward compatibility.

packages/runtime-class/src/runtime/components · high confidence

Marko 6 core tag translators moved to runtime-tags

The core tag translators (including \<const\>, \<let\>, \<for\>, \<if\>, \<await\>, \<define\>, \<id\>, \<script\>, and others) have been relocated from the compiler into the new \packages/runtime-tags\ package. This change introduces a dedicated runtime tag library for Marko 6, providing the implementation for core language features such as control flow, state management, and async handling. The diff also includes the new \\<attrs\>\ tag, which is deprecated in favor of destructuring \input\ via the \\<const\>\ tag, and the \\<class\>\ tag, which now throws a compile-time error to guide users toward \\<let\>\ and \\<const\>\ for state.

packages/runtime-tags/src/translator/core · high confidence

New DOM runtime implementation for Marko Tags API

The \packages/runtime-tags/src/dom\ directory has been replaced with a new, standalone DOM runtime implementation for the Marko Tags API. This change introduces a complete rewrite of the client-side rendering engine, including new modules for handling abort signals (\abort-signal.ts\), event delegation (\event.ts\), and a priority-queue-based render scheduler (\queue.ts\). It adds support for controllable native form elements (\controllable.feat.ts\), dynamic tag variables (\dynamic-tag-var.feat.ts\), and lazy-loaded templates (\load.ts\). The new runtime also implements a compatibility layer (\compat.ts\) to bridge the Tags API with the legacy Class runtime, ensuring smooth interoperability during migration.

packages/runtime-tags/src/dom · high confidence

New HTML runtime implementation for the Tags API

The HTML compilation path for the Tags API has been replaced with a new runtime implementation located in \packages/runtime-tags/src/html\. This new runtime introduces dedicated modules for handling assets (including lazy loading with visible, idle, media, and event triggers), attribute processing (such as controlled \\<select\>\ and \\<textarea\>\ values), and template rendering. It also includes a compatibility layer to bridge the Tags API with the existing Class API, ensuring that server-side rendering and client-side hydration work correctly across both systems.

packages/runtime-tags/src/html · high confidence

New core tags and runtime support for async rendering and component initialization

This change introduces the core implementation files for several new runtime tags in the \core-tags\ package. It adds the \\<await\>\ tag logic (including \AsyncValue\, client-side reordering via \client-reorder\, and timeout handling), the \\<init-components\>\ tag for managing UI component initialization in both sync and async contexts, the \\<preferred-script-location\>\ tag for controlling script placement, and the \\_\_flush\_here\_and\after\\_\ tag for controlling render flushing. It also includes type definitions for the \\<script\>\ tag and a new ESLint configuration for the package.

packages/runtime-class/src/core-tags · high confidence

New program-level translator visitors for DOM and HTML output

The translator now uses dedicated \dom.ts\ and \html.ts\ visitors within the program scope to handle template compilation. For DOM output, the new logic manages content registration, closure handling, and setup function generation, while also optimizing text-only conditionals and hoisting static placeholder text. For HTML output, it handles element resolution, hoisting, and global state management. These changes replace the previous program-level handling, improving how the compiler processes template structure and runtime registrations.

packages/runtime-tags/src/translator/visitors/program · high confidence

New runtime-tags common module with validation and iteration helpers

The \packages/runtime-tags/src/common\ directory now contains a new set of shared runtime utilities. This includes strict validation logic in \errors.ts\ that throws descriptive errors for invalid attribute values (such as functions or unrenderable objects), invalid \\<for\>\ tag keys, and incorrect attribute names, along with debug warnings for silently dropped values like \NaN\. The module also introduces iteration helpers (\for.ts\) supporting \forIn\, \forOf\, \forTo\, and a new \forUntil\ range loop, as well as attribute handling utilities (\attr-tag.ts\) and type definitions for scopes and renderers.

packages/runtime-tags/src/common · high confidence

New tags API translator entry point in runtime-tags

The \packages/runtime-tags/src/translator/index.ts\ file now serves as the primary entry point for the Marko compiler's translator, establishing the 'tags' API as the preferred interface (\preferAPI = 'tags'\). This module configures the core tag library, defines the directory for tag discovery (\tags\), and exposes the translation, analysis, and transformation logic via extracted visitors. It also provides runtime entry file paths for HTML and DOM outputs, exposes a cheat sheet for coding agents, and extends the \@marko/compiler\ type definitions to include extra metadata for AST nodes like \MarkoTag\ and \MarkoAttribute\.

packages/runtime-tags/src/translator · high confidence

New translator utility modules for analysis, binding, and serialization

The translator's utility layer has been expanded with a suite of new modules that handle core compilation tasks. \analyze-errors.ts\ introduces a diagnostic-based error reporting system to collect all analysis mistakes in a single pass rather than throwing immediately. \binding-prop-tree.ts\ and \binding-has-prop.ts\ provide new data structures and logic for analyzing binding property paths and pruning unused content. \serialize-reasons.ts\ and \serialize-guard.ts\ (referenced in \branch-tag.ts\) manage the logic for determining which template sections need to be serialized for client-side updates. Additionally, \evaluate.ts\ adds expression evaluation capabilities to determine if values are constant or nullable, and \for-selector.ts\ implements logic to detect and optimize \for\ loop key selectors.

packages/runtime-tags/src/translator/util · high confidence

Removals

Removal of legacy RaptorJS core, async, and caching tag libraries

The \lib/taglibs\ directory has been cleared of the legacy RaptorJS templating implementation. This change removes the core tag handlers (including \c:if\, \c:forEach\, \c:choose\, \c:include\, \c:define\, and \c:write\), the async fragment tag (\async:fragment\), and the caching fragment tag (\caching:cached-fragment\), along with their associated compiler nodes, transformers, and taglib definitions. Templates relying on these specific RaptorJS tags will no longer be processed by this library.

lib/taglibs · high confidence

Removal of legacy templating runtime entry points and configuration

The library has removed several core files that previously provided the main templating runtime and its environment-specific extensions. Specifically, \lib/index.js\ (the main entry point), \lib/index\_async.js\ (async rendering support), \lib/index\_rhino.js\ (Java/Rhino bridge), and \lib/index\_server.js\ (server-side template loading and file rendering) have been deleted. Additionally, the configuration files \lib/async-optimizer.json\ and \lib/optimizer.json\ that defined dependencies for these modules have been removed. This change eliminates the legacy runtime interfaces and associated optimizer configurations from the library.

lib · high confidence

Architecture

Compiler refactored to use internal Babel copy and new plugin architecture

The Marko compiler now uses an internal copy of Babel rather than the host's Babel installation, ensuring consistent behavior and avoiding conflicts with the project's own dependencies. The core plugin logic has been restructured into a new \MarkoFile\ class and dedicated \migrate\ and \transform\ plugin modules, which handle tag-level hooks and transformations more cleanly. This change also introduces a new parser integration via \htmljs-parser\ and improves how the compiler manages file metadata, caching, and error reporting during the transformation phase.

packages/compiler/src/babel-plugin · high confidence

Internal Babel bundling and type declarations added

The compiler's internal module now includes a dedicated Babel wrapper (\packages/compiler/internal/babel/index.ts\) that re-exports core Babel functionality (such as \transformAsync\, \parse\, and \traverse\) along with specific plugins for TypeScript and CommonJS modules. This change introduces a static entry point designed to bundle Babel into \dist/babel.js\, ensuring that runtime-patched Marko AST additions are preserved by using static default imports rather than namespace imports. Additionally, a \modules.d.ts\ file has been added to provide TypeScript declarations for the various Babel packages used in this internal layer.

packages/compiler/internal · high confidence

New modular runtime entry points for DOM and HTML serialization

The runtime-tags package now exposes dedicated entry points for client-side DOM operations (dom.ts) and server-side HTML serialization (html.ts), replacing or supplementing previous monolithic exports. These modules provide specific APIs for control flow (if, for, show, try, await), attribute handling, event binding, and state management, allowing consumers to import only the functionality they need. The dom.ts entry point focuses on client-side runtime concerns like signal management, dynamic tag handling, and resume logic, while html.ts handles server-side rendering tasks such as escaping, asset loading, and HTML writing. This structural change supports better tree-shaking and clearer separation between client and server runtime concerns.

packages/runtime-tags/src · high confidence

New modular translator visitor structure in runtime-tags

The translator logic in \packages/runtime-tags/src/translator/visitors\ has been reorganized into a set of dedicated, modular files (e.g., \cdata.ts\, \comment.ts\, \placeholder.ts\, \function.ts\, \import-declaration.ts\). This change introduces specific handling for previously unsupported or generic elements—such as throwing errors for CDATA and XML declarations, and properly removing comments—while refining the analysis and translation of placeholders, static text, and function registrations. It also adds stricter validation for \load\ imports (enforcing default specifiers and resolving tag imports) and improves how the compiler tracks global references and abort signals for reactive state.

packages/runtime-tags/src/translator/visitors · high confidence

Refactor compiler internals to use an internal Babel copy and new utility modules

The compiler's \babel-utils\ directory has been restructured to rely on an internal copy of Babel (\@marko/compiler/internal/babel\) rather than the external \babel\ package, and now exports a comprehensive set of utility modules including \assert\, \compute\, \decode-html\, \diagnostics\, \get-file\, \imports\, \loc\, \parse\, \taglib\, \tags\, and \template-string\. This change introduces new capabilities for constant folding via \computeNode\ (supporting binary, unary, logical, conditional, template literal, and object expressions), improved error handling with non-throwing diagnostic channels (\diagnosticWarn\, \diagnosticDeprecate\, \diagnosticSuggest\), and refined parsing logic that better handles source locations, tag variables, and custom tag argument/attribute constraints. It also adds utilities for resolving relative imports, normalizing template strings, and tracking seen tags for watch file management.

packages/compiler/src/babel-utils · high confidence

Refactor tag translation into modular, tree-shakable visitor files

The tag translation logic in the runtime-tags package has been reorganized from a monolithic structure into distinct, modular visitor files (attribute-tag, custom-tag, dynamic-tag, native-tag, and index). This change introduces a new visitor pattern where each tag type is handled by its own dedicated module, improving code maintainability and enabling better tree-shaking of unused tag-handling code. The index file now acts as a central dispatcher that routes tag analysis and translation to the appropriate specialized visitor based on the tag type.

packages/runtime-tags/src/translator/visitors/tag · high confidence

Behavioural changes

2 commits (0 fixes) modifying packages/runtime-class/bin, packages/runtime-class/src/node-require

A change to existing behaviour in packages/runtime-class/bin, packages/runtime-class/src/node-require — 2 commits, 5 files: “chore: move translators into runtime packages”; “chore: drop dependencies that Node or the repo already covers”.

packages/runtime-class/bin, packages/runtime-class/src/node-require · medium confidence · unverified

2 commits (0 fixes) modifying packages/runtime-class/src/compiler, packages/runtime-class/translator

A change to existing behaviour in packages/runtime-class/src/compiler, packages/runtime-class/translator — 2 commits, 4 files: “chore: move translators into runtime packages”; “feat(compiler): rebuild taglib discovery as per-directory lookups read on first use”.

packages/runtime-class/src/compiler, packages/runtime-class/translator · medium confidence · unverified

3 commits (1 fix) modifying patches

A change to existing behaviour in patches — 3 commits (1 fix), 7 files: “build: convert monorepo from npm to pnpm”; “fix(compiler): give the Marko builders the defaults their definitions do”; “chore: update dependencies (jsdom 31, mocha 12, magic-string 1)”.

patches · medium confidence · unverified

6 commits (2 fixes) modifying packages/runtime-tags/scripts

A change to existing behaviour in packages/runtime-tags/scripts — 6 commits (2 fixs), 1 file: “refactor(runtime-tags): add tree-shakable feature modules”; “perf: switch from esbuild to rolldown for babel build”; “chore: keep the runtime dist as one module per entry, move a parser item”; and 3 more (refs \#3247).

packages/runtime-tags/scripts · medium confidence · unverified

8 commits (3 fixes) modifying packages/compiler/src/taglib

A change to existing behaviour in packages/compiler/src/taglib — 8 commits (3 fixs), 9 files: “feat(compiler): resolve taglib imports and package templates with resolve-sync”; “New parser (\#1786)”; “fix: compile the native \<selectedcontent\> tag”; and 5 more (refs \#1786).

packages/compiler/src/taglib · medium confidence · unverified

Build tooling overhaul: pnpm migration, parallel test runner, and native TypeScript support

The build system has been converted from npm to pnpm, introducing a new parallel test runner that distributes test suites across CPU cores to significantly reduce execution time. TypeScript source files are now executed directly via native Node.js type stripping, removing the previous dependency on @babel/register. Additionally, a new Babel plugin handles MARKO\_DEBUG expressions, and the package publishing workflow now supports aliasing packages to the main 'marko' scope.

scripts · high confidence

Compiler build system switches to rolldown bundling with optimized output

The compiler's build process has been refactored to use rolldown instead of per-file Babel processing, resulting in a single bundled output that improves performance and reduces bundle size. This change includes specific optimizations such as pruning unused Babel parser plugins and runtime helpers, stubbing optional dependencies to prevent hard errors, and resolving module references to avoid deadlocks. Additionally, the build scripts now handle type definitions by copying necessary Babel type declarations during the install phase, ensuring the published package remains functional and efficient for users.

packages/compiler/scripts · high confidence

Compiler configuration and entry points restructured

The compiler's configuration logic has been centralized into a new \config.js\ module, introducing explicit options for \linkAssets\ (enabling browser asset resolution and lazy loading), \hydrateInit\ (controlling automatic hydration initialization), and \stripTypes\ (managing TypeScript type removal). The main entry point (\index.js\) now exposes a \configure()\ function for setting global compiler defaults and implements error recovery diagnostics that include a coding agent fix guide. Additionally, the CommonJS register hook (\register.cjs\) has been updated to automatically install source-map-support when source maps are generated in development mode, ensuring accurate stack traces for compiled templates.

packages/compiler/src · high confidence

Improved HTML escaping and attribute handling in runtime helpers

The runtime HTML helpers now include robust escaping for script, style, and comment placeholders to prevent premature tag closure and potential injection issues, while also ensuring the ampersand character is correctly escaped in server-side rendered attributes. New helper modules for dynamic, merged, and specific (class/style) attributes standardize how HTML attributes are generated and validated, improving security and consistency in rendered output.

packages/runtime-class/src/runtime/html/helpers · high confidence

Improved interop translator feature detection and error reporting

The interop translator now more accurately distinguishes between Tags API and Class API templates by detecting specific features such as bound attributes, the \<show\> core tag, and templates located in 'tags' directories, while correctly ignoring raw open tags for attribute checks. Additionally, a new aggregate error builder provides users with detailed, syntax-highlighted code frames and precise file locations when compilation errors occur, improving the debugging experience for mixed API usage.

packages/runtime-tags/src/translator/interop · high confidence

Internal Babel traverse types adapted for Marko compiler

The compiler's type-generation scripts now include a custom \babel-traverse.js\ module that adapts the standard \@types/babel\_\_traverse\ definitions. This script injects Marko-specific metadata (such as \MarkoMeta\ and compiler \Config\) into the Babel file interface and generates type-checking methods for Marko AST node types, ensuring that internal type stripping and analysis correctly recognize Marko-specific structures.

packages/compiler/scripts/types · high confidence

Introduce new runtime-tags implementation with optimized rendering and event delegation

The runtime has been replaced with a new 'runtime-tags' implementation that significantly alters how components are rendered and events are handled. For users, this means the underlying rendering engine now uses a compact, encoded walk-code system for DOM traversal and delegates all event listeners to the document root, which can improve performance and reduce bundle size. The new runtime also introduces changes to how reactive signals and scopes are managed, potentially affecting how state updates are queued and processed, although the public API surface remains largely consistent for standard component usage.

.sizes/counter.csr · medium confidence

Marko 5 runtime-class package initialization and type alignment

The \packages/runtime-class\ package is now initialized with its core structure, including the runtime, compiler, and translator layers, along with debug/dist entry-point shims that conditionally load source or distribution files based on the \MARKO\_DEBUG\ environment. TypeScript definitions have been added to align Marko 5 Class API types with the Marko 6 Tags API, specifically ensuring that \renderBody\ is correctly typed on SVG tags and that HTML attributes inherit from the unified tag definitions.

packages/runtime-class · high confidence

Pre-commit hook now runs linting, build, and size snapshot generation

The pre-commit hook has been updated to execute lint-staged, build the project, and generate build size snapshots using pnpm. This ensures that code is linted, compiled, and size metrics are tracked and committed before every commit.

.husky · high confidence

Removal of legacy RaptorJS compiler modules

The templating compiler in lib/compiler has been refactored by removing several core modules that were part of the previous RaptorJS implementation, including AttributeSplitter, ElementNode, EscapeXmlContext, Expression, ExpressionParser, Node, ParseTreeBuilder, Taglib, TaglibCollection, and TaglibXmlLoader. This change eliminates the old module structure and prepares the compiler for the new module.exports CommonJS pattern.

lib/compiler · high confidence

Repository tooling and configuration overhaul

The repository has been restructured with a new set of configuration files to support a modern development workflow. Linting and formatting are now handled by oxlint and oxfmt, replacing the previous jshint setup. The test runner (mocha) is configured for parallel execution across CPU cores with specific memory limits and VM module support. TypeScript compilation is standardized via tsconfig.json, and bundle size tracking is managed through .sizes.json. Additionally, the monorepo is configured using pnpm workspaces, and a security policy has been added to guide vulnerability reporting.

(repo-wide) · high confidence

Runtime class package exposes tags API interop and debug build config

The runtime-class package now includes a new build configuration file (build.json) that enables debug mode by default, allowing for easier debugging of runtime behavior. Additionally, the package introduces a new translator module (translator.js) that creates an interoperability layer between the internal class-based API and the Marko tags API, exposing standard translator methods like transform, analyze, and translate through this interop wrapper. The main entry point (index.js) has been updated to export the createOut function from the runtime module and the load function from the internal loader, establishing the core runtime interface.

packages/runtime-class/src · high confidence

Taglib lookup now requires an explicit translator argument

The \buildLookup\ function in the taglib module now requires a translator instance to be passed as the second argument. Previously, the module would automatically fall back to requiring the default translator if none was provided; this implicit behavior has been removed. Users must now explicitly pass the translator (e.g., \require('marko/translator')\) when calling \buildLookup\ to ensure correct tag resolution, with a debug warning issued if the argument is missing.

packages/runtime-class/src/taglib · high confidence

Fixes

3 commits (2 fixes) fixing packages/runtime-tags/scripts/build-plugins

A fix in packages/runtime-tags/scripts/build-plugins — 3 commits (2 fixs), 2 files: “fix: incorrect decl hoisting in prod runtime build”; “chore: switch bundling and test snapshots to use rolldown”; “fix(runtime-tags): keep the CommonJS runtime strict and guard tree-shaking in build:sizes”.

packages/runtime-tags/scripts/build-plugins · medium confidence · unverified

Runtime helpers for class/tags interop, lazy loading, and serialization

This change introduces a suite of runtime helper modules in \packages/runtime-class/src/runtime/helpers\ to support the Marko runtime-class architecture. It adds \dynamic-tag.js\ and \render-tag.js\ to handle dynamic component rendering and event binding interoperability between Class and Tags APIs (converting camelCase props to dash-case and bridging \on-x\ events). It includes \load-tag.js\ and specific trigger helpers (\load-tag-visible-trigger.js\, \load-tag-idle-trigger.js\, etc.) to implement native asset management and lazy loading capabilities. Additionally, it provides \serialize-noop.js\ and \skip-serialize.js\ to fix serialization issues for implicit split components and hydration state, while \class-value.js\ and \style-value.js\ offer utility functions for rendering class and style attributes.

packages/runtime-class/src/runtime/helpers · high confidence

Stabilize Class API and Tags API interop runtime

The runtime compatibility layer in \packages/runtime-class/src/runtime/helpers/tags-compat\ has been significantly hardened to ensure reliable mixing of Marko 5 (Class API) and Marko 6 (Tags API) components. This update introduces dedicated entry points for DOM and HTML rendering (supporting both CommonJS and ESM, with debug variants) that bridge the two systems. Key improvements include robust serialization of Class API state into Tags chunks, correct handling of inert Class children within Tags parents, and fixes for event handler bridging and scope resumption. These changes prevent crashes during re-renders and ensure that inline scripts and component definitions are flushed correctly across the interop boundary.

packages/runtime-class/src/runtime/helpers/tags-compat · high confidence

Test coverage

45 commits adding/updating tests in packages/compiler/test; Added tests for compiler babel-utils helpers; Added translator tests for complex at-tag scenarios; Expanded test coverage for the Tags API runtime; Removed obsolete test infrastructure files.

Dependencies

Marko runtime-class package.json and internal module manifests added

The \packages/runtime-class\ directory now includes a \package.json\ defining the main \marko\ package (version 5.39.44) with dependencies on \@marko/compiler\ ^5.42.8 and \@marko/runtime-tags\ ^6.3.55, alongside a suite of internal \@internal/\*\ module manifests under \src/node\_modules\ that define browser/worker exports for component and loader logic. Additionally, \packages/runtime-tags\ (version 6.4.0) is present with its own dependency on \@marko/compiler\ ^5.42.10, and various test fixture \package.json\ files have been added to support taglib and config resolution tests.

(dependencies) · high confidence

Housekeeping

Initial DOM runtime size snapshot; Initial size snapshot for comments.csr component; New developer documentation for runtime-tags architecture and workflows; New size snapshot for SSR counter component; New size snapshot for comments SSR entry.

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

This is the PUBLIC form of this artifact. Findings are listed in full, but the details of SECURITY findings — which rule fired, in which file, on which line, and how to fix it — are deliberately withheld, and any secret-scanner results are excluded entirely. Where detail is absent here it was REMOVED FOR PUBLICATION; it is not missing from the analysis. The complete artifact is available from the repository owner.

Score

  • CAI 48 → 51 (+2.8)
  • Rubric changed (rubric-2026.10.5 → rubric-2026.11.4) — scores are not directly comparable.

Lenses

  • Code Health 55 → 56 (+0.7)
  • Architecture 65 → 65 (+0.0)
  • Maturity 48 → 53 (+4.8)
  • Readiness 42 → 44 (+1.8)
  • Security 51 → 57 (+5.5)
  • Performance 100 → 100 (+0.0)

Resolved (307)

  • (anonymous) (cognitive 33) (.sizes/comments.csr/runtime.js)
  • (anonymous) (cognitive 33) (.sizes/dom.js)
  • (anonymous) (cognitive 34) (packages/runtime-class/src/translator/tag/custom-tag.js)
  • (anonymous) (cognitive 53) (.sizes/dom.js)
  • (anonymous) (cognitive 63) (packages/runtime-class/src/translator/tag/native-tag[html]/index.js)
  • (anonymous) (cyclomatic 18) (.sizes/dom.js)
  • (anonymous) (cyclomatic 22) (packages/runtime-class/src/translator/tag/custom-tag.js)
  • (anonymous) (cyclomatic 33) (.sizes/dom.js)
  • (anonymous) (cyclomatic 45) (packages/runtime-class/src/translator/tag/native-tag[html]/index.js)
  • * (cognitive 53) (packages/compiler/src/taglib/loader/loadTagFromProps.js)
  • * (cyclomatic 31) (packages/compiler/src/taglib/loader/loadTagFromProps.js)
  • Change coupling: compat.ts ↔ template.ts (packages/runtime-tags/src/dom/compat.ts)
  • Change coupling: references.ts ↔ translate-var.ts (packages/runtime-tags/src/translator/util/references.ts)
  • Critical CVE: [GHSA redacted] (pnpm-lock.yaml)
  • Critical CVE: [GHSA redacted] (pnpm-lock.yaml)
  • Deprecated: glob (pnpm-lock.yaml)
  • FunctionTooLong: parser.parseMarko (packages/compiler/src/babel-plugin/parser.js)
  • High CVE: [GHSA redacted] (pnpm-lock.yaml)
  • High CVE: [GHSA redacted] (pnpm-lock.yaml)
  • High CVE: [GHSA redacted] (pnpm-lock.yaml)
  • …and 287 more

New (498)

  • (anonymous) (cognitive 31) (packages/runtime-class/src/translator/tag/custom-tag.js)
  • (anonymous) (cognitive 40) (.sizes/comments.csr/runtime.js)
  • (anonymous) (cognitive 40) (.sizes/dom.js)
  • (anonymous) (cognitive 50) (.sizes/dom.js)
  • (anonymous) (cognitive 60) (packages/runtime-class/src/translator/tag/native-tag[html]/index.js)
  • (anonymous) (cyclomatic 20) (packages/runtime-class/src/translator/tag/custom-tag.js)
  • (anonymous) (cyclomatic 32) (.sizes/dom.js)
  • (anonymous) (cyclomatic 43) (packages/runtime-class/src/translator/tag/native-tag[html]/index.js)
  • Change coupling: compat.feat.ts ↔ control-flow.ts (packages/runtime-tags/src/dom/compat.feat.ts)
  • Change coupling: compat.feat.ts ↔ template.ts (packages/runtime-tags/src/dom/compat.feat.ts)
  • Change coupling: finalize-references.ts ↔ solve-reasons.ts (packages/runtime-tags/src/translator/util/finalize-references.ts)
  • FileTooLong: util/sections.ts (packages/runtime-tags/src/translator/util/sections.ts)
  • FunctionTooLong: index.default (packages/runtime-class/src/translator/tag/native-tag[html]/index.js)
  • FunctionTooLong: parser.createMarkoBuilder (packages/compiler/src/babel-plugin/parser.js)
  • FunctionTooLong: renderer-legacy.createRendererFunc.renderer (packages/runtime-class/src/runtime/components/legacy/renderer-legacy.js)
  • High: security finding (details withheld)
  • Hotspot: packages/runtime-class/src/runtime/helpers/dynamic-tag.js (packages/runtime-class/src/runtime/helpers/dynamic-tag.js)
  • Hotspot: packages/runtime-class/src/translator/tag/custom-tag.js (packages/runtime-class/src/translator/tag/custom-tag.js)
  • Hotspot: packages/runtime-class/src/translator/tag/util.js (packages/runtime-class/src/translator/tag/util.js)
  • Hotspot: packages/runtime-tags/src/dom/walker.ts (packages/runtime-tags/src/dom/walker.ts)
  • …and 478 more

Changes since last survey

  • 164 commits — 92 feature/other, 72 fixes

By area

  • packages/runtime-tags — 110 commits
  • packages/compiler — 19 commits
  • (root) — 9 commits
  • agent-feedback/items — 9 commits
  • packages/runtime-class — 9 commits
  • .changeset/aria-role-types.md — 1 commit
  • .changeset/clear-cooks-march.md — 1 commit
  • .changeset/config.json — 1 commit
  • .changeset/five-rockets-fetch.md — 1 commit
  • .changeset/gentle-lights-like.md — 1 commit
  • .changeset/parser-builder.md — 1 commit
  • .changeset/short-snakes-watch.md — 1 commit
  • .changeset/wet-doors-kiss.md — 1 commit

Notable commits

  • fix: chore: refresh transitive dependencies with security fixes
  • fix: fix(compiler): build error text from each error's message, not its stack
  • fix: fix(compiler): depend on resolve-sync instead of bundling it
  • fix: fix(compiler): give the Marko builders the defaults their definitions do
  • fix: fix(compiler): leave a babel config's parser plugins as they are
  • fix: fix(compiler): move an empty nested control flow tag into attribute tags
  • fix: fix(compiler): never take a template's sourceMappingURL comment as its input map
  • fix: fix(compiler): read the root package through the configured file system
  • fix: fix(compiler): report a tag that fails to load where it is used, not from getTag
  • fix: fix(marko): skip spread attr names the HTML parser would split
  • fix: fix(runtime-class): hydrate the widgets below a legacy widget
  • fix: fix(runtime-class): key a Class attribute tag's body beside nested attribute tags
  • fix: fix(runtime-class): render Class API content wherever Tags renders content
  • fix: fix(runtime-class): resolve tags named by bindings a migrator adds
  • fix: fix(runtime-class): type a template's render as one signature
  • fix: fix(runtime-tags): a <try>'s <@placeholder> takes no parameters
  • fix: fix(runtime-tags): a define called in a dynamic tag's body carries its outer values
  • fix: fix(runtime-tags): a dynamic tag with attribute tags is not name-only
  • fix: fix(runtime-tags): a function whose readers' params no guard groups compiles
  • fix: fix(runtime-tags): add a direct alias's root to its section only on the root's own turn
  • …and 144 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

marko-js/marko 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 15 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 b2e80183fd90cd85edff26238238eb492d1273b3 — the exact code this score is about.
  • Scored under rubric-2026.11.4 — 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.65+preprod-3c33c1882dc1.