abi/screenshot-to-code
42.5
Weak · 14 November 2026
27.6k
lines of production code
TypeScript
with Python
8
measurements over time
What this system is
This system is a full-stack application that generates frontend code from various inputs, including screenshots, URLs, video recordings, and text descriptions. It features an agent-based backend that orchestrates multiple LLM providers to produce HTML/CSS/JS, supporting iterative editing through a 'select-and-edit' interface and multi-variant previews. The platform also includes comprehensive evaluation tools for comparing model performance and detailed logging for debugging and cost tracking.
How it got here
2023 — Initial project scaffolding and core feature development
13 changes.
This period established the foundational architecture for the application, initializing both the FastAPI backend and the Vite/React frontend with essential dependencies and configuration. Key features implemented include the core code generation engine with streaming updates, a modular backend structure for LLM provider abstraction, and a comprehensive evaluation dashboard for comparing model outputs. The work also introduced critical UI components, state management, and infrastructure for cost tracking and user history.
2024 — video input and design system integration
18 changes.
This period focused on expanding the application's input capabilities by adding screen recording and video processing support, alongside a comprehensive redesign of the frontend interface to include select-and-edit modes and version navigation. Concurrently, the backend was enhanced to support persistent design systems for guided code generation and introduced robust evaluation and logging infrastructure to improve reliability and observability.
2025–2026 — Agent tooling and input unification
14 changes.
This period focused on expanding the backend agent's capabilities by introducing new tools for asset extraction, image editing, and modular prompt construction, alongside enforcing stricter output and cost controls. The frontend was updated with a unified input pane for diverse code generation sources and a detailed activity timeline to visualize the agent's reasoning process.
Features
Add Cursor Cloud installation script
A new shell script, scripts/cursor-cloud-install.sh, has been added to automate the setup of the development environment. This script installs Poetry and pnpm, sets up the backend and frontend dependencies, installs the Chromium browser for Playwright, and conditionally installs dependencies for the screenshot-to-code-saas backend and admin projects if they are present in the directory structure.
scripts · high confidence
Add screen recording capability with preview and re-record
Users can now capture their screen as a video input for code generation. This change introduces a new ScreenRecorder component that utilizes the browser's MediaRecorder API to record screen activity into a WebM video. After recording, users are presented with a preview of the captured video, allowing them to either generate code from it or re-record if the result is unsatisfactory. The implementation includes utilities for converting the video blob to a base64 data URL and ensures that the screen sharing stream is properly stopped after the recording session ends.
frontend/src/components/recording · high confidence
Add video processing utility functions
The backend now includes utility functions to support video handling. Specifically, \extract\_tag\_content\ allows parsing content from within specific XML-style tags in text, and \get\_video\_bytes\_and\_mime\_type\ decodes base64-encoded video data URLs into raw bytes and their corresponding MIME types. These utilities provide the foundational logic for processing video inputs within the application.
backend/video · high confidence
Added Terms of Service page
A new Terms of Service page has been added to the public legal documents, outlining the rules for using the AI screenshot-to-code generation services, including user responsibilities, intellectual property rights, payment terms, and liability disclaimers.
frontend/public · high confidence
Added shadcn/ui component library
The frontend now includes a new set of reusable UI components (accordion, alert-dialog, badge, button, checkbox, collapsible, dialog, hover-card, input, label, popover, progress, scroll-area, select, separator, switch, tabs, and textarea) built on top of Radix UI primitives. These components provide a consistent, accessible, and themeable foundation for the application's interface.
frontend/src/components/ui · high confidence
Backend scaffolding and model configuration
The backend directory is initialized with a FastAPI application structure, including a new \llm.py\ file that explicitly maps supported models (GPT-5.4/5.5/5.6, Claude Opus/Fable/Sonnet, Gemini) to their providers and reasoning efforts. The application now includes a startup script (\start.py\) that automatically finds an available port on 7001, a Dockerfile for containerization, and configuration for pre-commit hooks and type checking. Additionally, new routes are registered for capabilities, screenshots, code generation, evals, exports, and design systems, while utility functions are added for prompt summarization and debugging.
backend · high confidence
Initial frontend application structure and core generation logic
This change introduces the foundational frontend codebase for the application. It establishes the main application shell (App.tsx) with state management via Zustand stores, a WebSocket-based code generation engine (generateCode.ts) for streaming updates from the backend, and a comprehensive settings system supporting API keys for OpenAI, Anthropic, Gemini, and Replicate. The UI includes a sidebar with history and icon strip, a preview pane, and a start pane, along with configuration for dark mode, design systems, and persistent user preferences. Routing is set up to support the main app and a dedicated section for evaluation tools (/evals).
frontend/src · high confidence
Initial frontend scaffolding with Vite, React, and Tailwind
The frontend application has been initialized with a new Vite-based build system, replacing the previous setup. This introduces a React development environment configured with TypeScript, ESLint, and PostCSS. The UI layer is built using Tailwind CSS and shadcn/ui components, providing a styled foundation for the interface. The configuration supports environment-based injection for analytics (Plausible) in hosted versions and includes a dev-server proxy to route backend API and WebSocket requests to a local backend on port 7001, facilitating local development and tunneling.
frontend · high confidence
Introduce Replicate-based image generation with background removal and editing tools
The backend now supports image generation via Replicate, defaulting to the Z Image Turbo model (with Flux 2 Klein available as an alternative). This change adds a background removal tool and an image editing tool backed by Replicate, while limiting concurrent API requests to 20 per tool call to manage load.
_backend/image\generation · high confidence
Introduce Select-and-Edit mode with visual overlays and context-aware targeting
Users can now enter a dedicated 'Select & edit' mode via a new toggle button in the preview toolbar. While active, hovering over elements displays a distinct visual overlay, and clicking locks the selection with a separate indicator, allowing users to visually target specific DOM nodes for editing. The mode can be exited explicitly via the toolbar button or by pressing the Escape key. To ensure precise edits, the system captures the selected element's rendered HTML and augments it with a DOM location path (e.g., \body \> div.card \> a.btn\) and duplicate-count context, helping the AI distinguish between identical elements on the page.
frontend/src/components/select-and-edit · high confidence
Introduce agent activity timeline with collapsible steps and generation timing
The agent interface now displays a structured activity timeline that groups consecutive tool calls and thinking events into collapsible step rows, keeping assistant responses distinct. This view includes syntax-highlighted code previews, expandable prompt text, and specific timing displays: live elapsed time during generation and a stable total duration for completed variants.
frontend/src/components/agent · high confidence
Introduce asset persistence and model integration for uploaded images
The backend now includes a new \uploaded\_assets\ module that enables the system to persist uploaded images as permanent assets and integrate them into AI model interactions. This change adds a \save\_assets\ tool that allows the agent to promote temporary image IDs to permanent public URLs, ensuring images are available for use in generated code. Additionally, prompt handling logic has been updated to append asset IDs to user prompts and history, and the tool execution now attaches image bytes directly to the model response to bypass cloud model limitations with local asset URLs.
_backend/uploaded\assets · high confidence
Introduce backend evaluation runner for text and image sets
The backend/evals directory now provides the core infrastructure to run model evaluations against both image and text input sets. This includes configuration for the evaluation data directory, core logic to invoke the agent runner for code generation, and a runner module that handles input resolution, output folder organization, and retry logic for failed generations.
backend/evals · high confidence
Introduce commit and variant data structures with creation utility
The commits component now defines its core data model through new \types.ts\ and \utils.ts\ files. This introduces structured types for \Commit\ (including AI create/edit and code create variants), \Variant\ (with status, history, and agent event tracking), and \AgentEvent\, enabling the frontend to manage commit history and variant states more explicitly. A \createCommit\ helper is added to standardize the generation of new commit objects with unique hashes and initial states.
frontend/src/components/commits · high confidence
Introduce multi-variant preview with keyboard shortcuts and model badges
The Variants component now displays multiple generated code options side-by-side as live, scaled iframe previews. Users can switch between variants using Alt+1 through Alt+9 keyboard shortcuts, provided the commit is not yet committed. Each variant tile includes a color-coded badge indicating the model tier (Fast/Max) and a status indicator (green for complete, red for error/cancelled, gray for pending). The component also handles responsive scaling of the iframe previews and shows a working pulse animation during generation.
frontend/src/components/variants · high confidence
Introduce unified input pane for code generation
A new unified input pane has been added to the frontend, consolidating code generation inputs into a single tabbed interface with Upload, URL, Text, and Import options. This component manages the generation workflow by passing stack and design system settings to individual tabs and includes a dedicated controls component for screenshot-to-code tasks, featuring an optional asset extraction toggle and expandable instruction fields.
frontend/src/components/unified-input · high confidence
Introduce unified input pane for code generation
The StartPane component now renders a new UnifiedInputPane, consolidating the initial interaction area for code generation. This change introduces support for image and video input modes, optional text prompts accompanying image uploads, and asset extraction preferences, while also integrating persistent design systems for prompts into the generation workflow.
frontend/src/components/start-pane · high confidence
Introduce unified input tabs for code, text, URL, and file uploads
The unified input pane now presents four distinct tabs—Import, Text, Upload, and URL—allowing users to choose their preferred method for providing design context. The Import tab enables pasting HTML code or dragging and dropping .html files, while the Text tab supports generating UI from natural language descriptions with example prompts. The Upload tab handles multiple image screenshots (up to 5) and video recordings, including fixes for MOV file MIME types, and the URL tab captures public webpages via ScreenshotOne, with specific handling and warnings for Figma URLs. Each tab integrates stack selection and design system settings to tailor the generated output.
frontend/src/components/unified-input/tabs · high confidence
New AI thinking indicator component
A new ThinkingIndicator component has been added to the frontend to display the AI's reasoning process. It shows a collapsible panel with the AI's thought content, providing status updates such as 'AI is thinking...', 'reasoning', or 'AI thought for Xs'. The indicator is designed to appear only for the latest commit, ensuring historical commits do not display this active thinking state.
frontend/src/components/thinking · high confidence
New Evals Dashboard and dedicated pages for agent runs, sessions, and prompt reports
The evals interface now features a central Evals Dashboard (AllEvalsPage) that links to dedicated pages for running evaluations, comparing model outputs, viewing prompt reports, and inspecting agent runs. A new AgentRunsPage provides a detailed timeline view of agent execution, including per-turn LLM and tool usage, costs, and token counts. The EvalSessionsPage and EvalComparePage introduce a session-based matrix view for comparing model outputs across multiple inputs side-by-side, with support for filtering by winner and synchronized scrolling. Additionally, a PromptReportsPage allows browsing logged LLM requests with usage and cost details, and an OpenAIInputComparePage helps identify divergences between two request payloads.
frontend/src/components/evals · high confidence
New agent tools for asset extraction, background removal, and image editing
The agent now includes new tools to extract visual assets from screenshots, remove image backgrounds, and edit images using Replicate. The extract\_assets tool uses Gemini to identify and save specific visual elements, while remove\_backgrounds and edit\_images handle image processing with local asset URLs automatically converted to base64 data URLs for external API compatibility. These tools support batch processing and parallel execution for improved performance.
backend/agent/tools · high confidence
New core UI components for shortcuts, loading states, and stack identification
This change introduces four new reusable components in the core library: KeyboardShortcutBadge for displaying keyboard shortcuts with special handling for the Enter key, Spinner for accessible loading indicators, StackLabel for visualizing technology stacks with framework logos, and WorkingPulse for subtle activity animations. These components provide consistent visual feedback and UI elements across the application.
frontend/src/components/core · high confidence
New design system management and refined settings UI
Users can now create, edit, and delete custom design systems (color, typography, and layout rules) via a new modal interface, with a selector integrated into the generation settings to apply these systems to code output. The settings page has been restructured into a full-page tab view, featuring a dedicated section for API keys (OpenAI, Anthropic, Replicate) stored locally in the browser, theme selection (app and editor), and a stack selector that is hidden in video mode. Screenshot preview availability is now gated by backend capability checks.
frontend/src/components/settings · high confidence
New frontend hooks for UI indicators, state persistence, and performance
This change introduces four new React hooks to the frontend. The \useBrowserTabIndicator\ hook dynamically updates the browser tab title and favicon (including a dev-mode colored dot) based on whether the application is in a 'coding' state. The \useDesignSystems\ hook provides a client-agnostic interface for fetching, creating, updating, and deleting design systems, handling loading states and error toasts. The \usePersistedState\ hook manages React state that is automatically synchronized with \localStorage\. Finally, the \useThrottle\ hook improves performance by throttling rapid updates (defaulting to 500ms) using \performance.now\, which helps prevent UI freezing during high-frequency events like code generation previews.
frontend/src/hooks · high confidence
New frontend library utilities and model configuration
This change introduces several new modules in the frontend library. It adds a model configuration system (models.ts) defining available AI models (e.g., GPT-5.5, Claude Opus 5.5, Gemini 3.6 Flash) and logic to display variant badges like 'Fast' or 'Max' based on the generation context. It also includes a design systems client abstraction for managing design system resources via HTTP, a Babel CDN pinning utility to ensure stable React rendering in generated code, and helper functions for screenshot capture, class name merging, and prompt history management.
frontend/src/lib · high confidence
New image lightbox, code import, and terms-of-service dialog components
The frontend now includes several new UI components: ImageLightbox.tsx provides a zoomable image viewer with a max zoom of 10x and a default display width of 1000px; ImportCodeSection.tsx allows users to paste HTML code and select a target stack for import; TermsOfServiceDialog.tsx collects user emails and displays partner logos for the hosted version; and UpdateImageUpload.tsx enables uploading up to 5 reference images for follow-up edits with a preview and removal interface.
frontend/src/components · high confidence
New on-disk agent run logging with SQLite indexing and asset capture
A new \fs\_logging\ module has been added to capture full agent run details to disk when \PROMPT\_REPORTS\_ENABLED\ is active. This includes recording every LLM call (payloads, responses, token usage, costs), tool calls, and streamed deltas with timestamps. The system stores structured data in a SQLite index (\index.db\) and creates per-run directories containing event logs, summaries, final HTML output, and a snapshot of referenced assets (including expiring remote images). It also provides utilities for serializing and summarizing complex input/output structures for logging purposes.
_backend/fs\logging · high confidence
New prompt builders for file snapshot and history-based updates
The backend now includes dedicated prompt construction logic for update operations, exposed via \backend/prompts/update\. Two new functions, \build\_update\_prompt\_from\_file\_snapshot\ and \build\_update\_prompt\_from\_history\, allow the system to generate update prompts either from a current file state or from a conversation history. Both builders integrate selected stack policies, image generation policies, and optional design system blocks into the final prompt structure.
backend/prompts/update · high confidence
Unified provider abstraction with structured cost tracking and text-based eval sets
The backend now uses a standardized provider interface (base.py) to manage interactions with Anthropic, Gemini, and OpenAI, introducing structured cost tracking via new pricing and token-usage modules that calculate spend based on input, output, and cache tokens. This change also adds support for text-based evaluation sets alongside existing image sets, allowing users to run evaluations against briefs defined in JSON rather than just image inputs.
python · high confidence
Behavioural changes
Agent engine enforces output requirements and spend ceilings
The agent engine now fails runs that finish without producing any HTML output, preventing empty results from being treated as successful generations. It also aborts any generation that exceeds a configured $3 spend ceiling, ensuring resource usage stays within budget limits.
backend/agent · high confidence
Custom WebSocket error code for application errors
The backend now uses a specific custom WebSocket close code (4332) to signal application-level errors, such as missing configuration like an OpenAI API key, allowing clients to distinguish these from standard protocol errors.
backend/ws · high confidence
Enforce Anthropic image size and dimension limits
The Anthropic provider now automatically processes images before sending them to the API, ensuring they comply with Claude's vision constraints. Images are resized to a maximum dimension of 7990 pixels (with a stricter 2000x2000 limit when a request contains more than 20 images) and compressed to stay under the 5 MB per-image size limit. This prevents API rejections for oversized inputs and may reduce latency by optimizing image payloads.
backend/agent/providers/anthropic · high confidence
Introduce unified provider session factory and tool gating
The agent backend now uses a centralized factory in \backend/agent/providers\ to create provider sessions for OpenAI, Anthropic, and Gemini models. This change introduces dynamic tool availability based on configuration: image editing is gated by the presence of a Replicate API key, asset extraction requires a Gemini key, and screenshot preview is disabled if headless Chromium is unavailable. A backwards-compatible alias (\StepResult\) is also provided for existing imports.
backend/agent/providers · high confidence
Migrate state management to Zustand
The application's frontend state management has been migrated from the previous implementation to Zustand. This change introduces new store modules (app-store and project-store) that manage global state for UI interactions (such as select-and-edit mode and image inputs) and project data (including commits, variants, and agent events). The migration ensures atomic state updates, such as clearing selection targets when version history changes, and provides a foundation for supporting multiple image inputs and non-blocking updates.
frontend/src/store · high confidence
Modularize backend routes and update model configurations
The backend's routing structure has been refactored by splitting the previous monolithic main.py into dedicated route modules (home, screenshot, model\_choice\_sets). This change introduces a new home status endpoint and a screenshot capture endpoint that utilizes the ScreenshotOne API, including logic to normalize URLs with domain:port combinations. Additionally, the model selection logic has been updated to reflect new model availability, specifically switching image-create defaults to Opus 5.5 and GPT-6.1 Sol, and refreshing text-create model mixes based on recent evaluations.
backend/routes · high confidence
New modular prompt builders for image, text, and video input modes
The backend now uses a new \backend/prompts/create\ module to construct AI prompts based on the input type. A central dispatcher routes to specialized builders: image mode now includes detailed instructions for asset extraction, upscaling, and multi-screenshot organization; text mode generates UI code with modern styling guidelines; and video mode instructs the model to recreate functional apps from interaction videos. All builders integrate stack policies, design systems, and image generation policies.
backend/prompts/create · high confidence
Redesigned history panel with media thumbnails and version lineage
The history view has been redesigned to display a chronological list of project versions, each showing a version number badge, a summary of the change, and a colored pill indicating the type (Create, Edit, or Imported from code). For AI-generated edits, the panel now includes thumbnails of associated images and videos; clicking a video thumbnail expands the item and auto-plays the media. The view also displays lineage information, showing which previous version an edit was based on when it branches from the main history. This change is implemented in the new HistoryDisplay component and its supporting utility functions, which pre-process commit data for rendering and testing.
frontend/src/components/history · high confidence
Redesigned preview pane with version navigation, select-and-edit, and new code tools
The preview pane has been restructured to include a new Code tab featuring a CodeMirror editor with copy and CodePen integration, alongside a dedicated download button that exports code via the backend. A new version navigation control allows users to step through generation history, while the preview iframe now supports a 'select-and-edit' mode with visual overlays and hash-link suppression. The interface also adds an 'Open in New Tab' action, refined desktop scaling controls, and a visual scanning animation for image-based inputs.
frontend/src/components/preview · high confidence
Refactored prompt assembly with persistent design system support
The backend prompt generation logic has been restructured into a modular pipeline that explicitly supports persistent design systems. Users can now provide a design system definition, which is injected into the system prompt with high priority to guide code generation. The refactored message builder also correctly handles multi-modal history, ensuring that images and videos are properly formatted alongside text in conversation turns, and enforces strict type safety for stack configurations and prompt construction strategies.
backend/prompts · high confidence
Screenshot preview backend refactored for pluggability and reliability
The screenshot preview tool now uses a pluggable backend architecture, allowing deployments to swap the default local Chromium renderer (via Playwright) for alternative implementations like external APIs without changing the core feature code. This change introduces a stable interface and registry, ensuring consistent viewport sizes across devices and handling browser availability checks gracefully. Additionally, the backend normalizes the Babel CDN in generated React pages to ensure they render correctly before capturing the screenshot, fixing issues where pages might fail to mount.
_backend/preview\screenshot · high confidence
Sidebar redesigned with icon strip and new layout
The sidebar has been restructured to feature a new IconStrip component that provides vertical navigation for the Editor, Versions (previously History), and Settings panels, along with a dedicated button to start a new project. This change replaces the previous sidebar layout, introducing a more compact, icon-driven interface that organizes key actions and navigation tools into a distinct strip.
frontend/src/components/sidebar · high confidence
Fixes
Improved HTML extraction from LLM-generated code
The code generation module now uses a robust utility to extract HTML content from LLM outputs, handling markdown code fences, DOCTYPE declarations, and nested file tags. This ensures that the video mode preview correctly displays the generated code by stripping away explanatory text and formatting artifacts, fixing the issue where the preview was not showing the expected output.
backend/codegen · high confidence
Test coverage
Added comprehensive test coverage for backend agent engine, tools, and evaluation systems; Added deterministic QA end-to-end test suite.
Dependencies
Initial dependency manifests for backend and frontend
The project now includes explicit dependency manifests for the backend (pyproject.toml with Poetry) and frontend (package.json with pnpm), along with their respective lockfiles (poetry.lock and pnpm-lock.yaml). The backend specifies Python 3.10+ and includes libraries such as FastAPI, Anthropic, OpenAI, Playwright, and Langfuse. The frontend specifies React, Vite, Tailwind CSS, and Radix UI components. A root package.json defines pnpm workspaces to manage both sub-projects.
(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 34 → 43 (+9.0)
- Rubric changed (rubric-2026.10.5 → rubric-2026.11.4) — scores are not directly comparable.
Lenses
- Code Health 53 → 51 (-2.1)
- Architecture 83 → 81 (-1.8)
- Maturity 63 → 78 (+14.6)
- Readiness 20 → 25 (+4.9)
- Security 35 → 98 (+62.6)
- Accessibility 42 → 45 (+3.4)
- Performance 100 → 100 (+0.0)
Resolved (11)
- Change coupling: types.ts ↔ HistoryDisplay.tsx (frontend/src/components/commits/types.ts)
- Context/problem (why multipart content is needed for AI models) and consequences/trade-offs are implied but not stated in the visible text (design-docs/images-in-update-history.md)
- Decision is a vague 'used for model selection (but it shouldn’t be really? I don’t know)' with no context and no consequences; the body is an input-mode list plus a one-line rationale (design-docs/general.md)
- Documentation: no contributor guidance (README.md)
- Duplicated block (5 lines × 2) (backend/evals/asset_extraction_benchmark.py)
- High CVE: [GHSA redacted] (frontend/pnpm-lock.yaml)
- High CVE: [GHSA redacted] (frontend/pnpm-lock.yaml)
- High CVE: [GHSA redacted] (frontend/pnpm-lock.yaml)
- High CVE: [GHSA redacted] (backend/poetry.lock)
- Medium CVE: [GHSA redacted] (backend/poetry.lock)
- Medium CVE: [GHSA redacted] (backend/poetry.lock)
New (22)
- Edited copies of one member (3 members, 11+ corresponding lines) (backend/agent/providers/anthropic/provider.py)
- Edited copy of a member (13 corresponding lines) (backend/routes/evals.py)
- Edited copy of a member (18 corresponding lines) (backend/agent/tools/extract_assets.py)
- Edited copy of a member (18 corresponding lines) (backend/image_generation/replicate.py)
- Edited copy of a member (27 corresponding lines) (backend/utils.py)
- Edited copy of a member (8 corresponding lines) (backend/routes/agent_runs.py)
- High CVE: [GHSA redacted] (frontend/pnpm-lock.yaml)
- High CVE: [GHSA redacted] (backend/poetry.lock)
- High CVE: [GHSA redacted] (frontend/pnpm-lock.yaml)
- High CVE: [GHSA redacted] (frontend/pnpm-lock.yaml)
- Low CVE: [GHSA redacted] (frontend/pnpm-lock.yaml)
- Medium CVE: [GHSA redacted] (backend/poetry.lock)
- Medium CVE: [GHSA redacted] (backend/poetry.lock)
- redundant comment (frontend/src/App.tsx)
- redundant comment (frontend/src/App.tsx)
- redundant comment (frontend/src/App.tsx)
- redundant comment (frontend/src/components/history/utils.test.ts)
- redundant comment (frontend/src/components/history/utils.ts)
- redundant comment (frontend/src/components/recording/utils.ts)
- redundant comment (frontend/src/components/sidebar/Sidebar.tsx)
- …and 2 more
Architecture
- Unchanged — 0 containers · 1 contexts · 0 edges
Written by cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.
Survey your own repository
abi/screenshot-to-code 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 14 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 a8139779f7c5ae231b7f2a86fa7f83ddc5f7badc — 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-36d4cd83012f.