Modules
Elixir-native frontend build tool.
Static asset handling — images, fonts, SVGs, and other non-code files.
Query helpers for asset module request modes.
Production build — resolve dependencies, split chunks, bundle, and write assets.
Options required while rendering production build output.
Walks the dependency graph from entry files, collecting modules and workers.
State accumulated while walking the production dependency graph.
Shared build graph context used while collecting and compiling modules.
Static and dynamic dependency lists for one collected module.
Rewrite external imports into global variable access for production builds.
Manifest entry written to production manifest.json.
Builds final production output files from compiled module graphs.
Context passed to final JavaScript and CSS output rendering.
Metadata for one generated production output file.
Resolve import specifiers to absolute file paths for the build graph.
Production build result returned from Volt.Builder.
Rewrites production bundle imports, workers, externals, and chunk references.
Writes production JavaScript, CSS, assets, sourcemaps, and manifests.
Helpers for parser-backed CSS AST transforms.
Parser-backed CSS asset URL rewriting for production builds.
CSS Modules support for .module.css files.
ETS-backed module cache keyed by path.
Build a chunk graph from module dependencies.
A JavaScript output chunk in the production dependency graph.
Read Volt configuration from application environment.
Normalized production build configuration.
Profile argument parsing for Volt Mix tasks.
Normalized development server configuration.
Plug that serves compiled frontend assets in development.
Cached development-server compilation result.
Resolved runtime configuration for the development server plug.
Small helpers for Volt's named ETS tables.
Load environment variables for client-side code.
A mix format plugin that formats JavaScript and TypeScript files with oxfmt.
Detects HMR boundaries from the dev module graph and source ASTs.
Tracks import.meta.glob() ownership for HMR invalidation.
ETS-backed raw import graph for HMR boundary fallback.
JSON message sent over the HMR WebSocket protocol.
ETS-backed dev-server module graph.
A dev-server module graph node.
WebSocket handler for HMR updates.
Extract entry points from HTML files.
Helpers for matching and editing OXC JavaScript AST nodes.
Access to JavaScript and TypeScript support assets bundled with Volt.
JavaScript, TypeScript, CSS, and asset extension groups used by Volt.
Loads JavaScript formatter configuration for oxfmt.
Shared JavaScript file discovery helpers for Mix tasks.
Extracts static, dynamic, CJS, and worker imports from JavaScript source.
Structured result returned by JavaScript import extraction.
Small struct wrapper for source patches applied through OXC.
Generates synthetic JavaScript entry modules for vendor prebundling.
Export descriptor used by synthetic prebundle entries.
Import descriptor used by synthetic prebundle entries.
Shared JavaScript package resolution defaults.
Import specifier resolution with alias support.
Runs JavaScript build tools through QuickBEAM with package dependencies isolated from the user's application.
Bundles QuickBEAM runtime entry files and their dependencies.
Materializes JavaScript runtime entry assets for QuickBEAM.
Error returned when a JavaScript runtime cannot be prepared or started.
Installs isolated npm runtime packages for QuickBEAM-backed plugins.
Package signature stored beside a JS runtime installation.
Read compilerOptions.paths from tsconfig.json and convert to Volt aliases.
Rewrites new URL("./asset.ext", import.meta.url) references to asset imports.
Rewrites relative template-literal dynamic imports into import maps.
Patch metadata for dynamic import variable replacements.
Transforms import.meta.glob() calls into static import maps.
Parsed import.meta.glob call options.
Resolved file entry for import.meta.glob expansion.
Injects import.meta.env values into JavaScript modules when referenced.
Rewrite import specifiers in compiled JS output using AST positions.
Rewrites JavaScript import and require specifiers while collecting resolved paths.
Finds and rewrites new Worker(new URL(..., import.meta.url)) module specifiers.
Pre-bundle vendor (node_modules) dependencies for dev mode.
Filesystem path helpers shared across Volt runtime modules.
Compile source files to browser-ready JavaScript and CSS.
Compiled output returned by Volt.Pipeline.compile/3.
Content hashes for framework single-file component blocks.
Behaviour for Volt build plugins.
Built-in React prebundle coordination for Volt dev mode.
Solid JSX/TSX support for Volt.
Solid compiler options encoded for the JavaScript runtime.
Nested Solid preset options passed to Babel.
Built-in Svelte support for Volt.
Svelte compiler options encoded for the JavaScript runtime.
Execute Volt plugin hooks.
Generate <link rel="modulepreload"> tags for production chunks.
Optional Vite-style public directory support.
Tailwind CSS integration — scan source files for candidates and compile CSS.
Handles Tailwind module loading, prebundling CJS graphs via OXC, and stylesheet resolution.
Resolves stylesheet and module paths for the Tailwind runtime.
Helpers for URL path, query, and fragment handling.
File watcher that triggers recompilation, Tailwind rebuilds, and HMR updates.
Mix Tasks
Build production frontend assets.
Start the Volt file watcher for development.
Install and configure Volt in a Phoenix project
Check formatting and lint Volt's JavaScript and TypeScript assets via NIF.
Format Volt's JavaScript and TypeScript assets with oxfmt via NIF.
Lint project JavaScript and TypeScript assets using oxlint via NIF.