Crate Reference

This page documents every crate in the bext workspace. Use it to find where a feature lives, what types it exposes, and how crates depend on each other. For the high-level layout and feature-flag matrix, see Architecture overview.

The workspace contains ~36 top-level crates plus ~33 reference-implementation crates under crates/bext-impls/. The default-features build links V8 + the bext-turbopack bundler; everything else is feature-gated so a minimal build stays small.

Server + core

bext-server

Main binary — actix-web HTTP server, masquerade router, vhost.

Key modules:

bext-core

Shared logic across the server, the NAPI plugin, and CLI tools.

Key modules:

bext-impls

Trait implementations that glue bext-core to optional ecosystems.

A directory of small adapter crates. Each implements a trait defined in bext-core or bext-plugin-api. The base build links none of them; features in bext-server opt into the ones you want.

These are deliberately tiny. Pick the ones you need; nothing else links in.

bext-license

Offline Ed25519 license key validation.

Key types: LicensePayload, Tier (Community / Pro / Enterprise), Feature, validate_key(). 14-day grace period after expiry before falling back to Community tier.

bext-keygen

License key generation utility (binary).

Internal tool. Signs LicensePayload blobs with the Ed25519 private key.

PRISM / framework pipeline

bext-turbopack

Direct API around utoo / Turbopack — JSX/TSX → JS bundle.

Owns the PRISM compile pass call sites. Two hooks call into bext-core::transform::prism_compile:

- compile_closure — entry source on first-request compile

• transform_with_analysis_opts — every transitive import traversed by the bundler

Modules: direct (compile entry points + transform integration), prism (PRISM-specific bundle setup, byte-equivalence test scaffolding), registry (compiled-route cache), walker (transitive-closure walker), watch (file watcher invalidating the registry on save).

bext-v8

rusty_v8 SSR isolate.

Modules: eval (eval thread + page-context cache, used by both PRISM SSR and Next.js compat), pump (streaming-render pump from V8 to the HTTP response), pool (per-tenant isolate pool with idle eviction), atomize (string interning helpers).

The same isolate runtime is reused by bext-plugin-v8 for plugin sandboxing. See V8 plugins.

bext-react-compiler

SWC + React Compiler integration.

Auto-memoization (React Compiler) for client islands and pure-function lowering for SSR-only code paths. Runs as part of the bundler's source transforms when the React Compiler is enabled in bext.config.toml.

bext-css

Rust-native Tailwind v4 engine.

Utility scanner (walks PRISM/JSX sources, extracts class names) and JIT class generator. Output is route-scoped CSS extracted at build time and served from the asset cache. No tailwindcss Node binary needed.

bext-import

AST-aware "use server" / "use client" / "use cache" directive scanner.

Used by the bundler to discover boundaries before splitting the graph for client/server bundles. Powers the [framework] type = "nextjs" RSC compile path and PRISM islands.

bext-proxy

Reverse-proxy subsystem.

Upstream pools, load balancing, circuit breakers, retries, gRPC proxying, WebSocket proxying. Extracted from bext-server in 2026-04 to cut incremental rebuild time.

Plugins

bext-plugin-api

Trait definitions and shared types. Deliberately lightweight.

Public types:

WASM guest crates can depend on this without dragging in actix-web, V8, or anything else heavy.

bext-plugin

NAPI addon for Bun (native plugin mode).

Used when bext is invoked as a Node/Bun-native module (the legacy "plugin" build) instead of as a standalone server. Exposes apply_source_transforms and the SSR pool over NAPI.

bext-plugin-wasm

wasmtime sandbox for WASM lifecycle plugins.

Modules: adapter (trait bridge), host_functions (host imports), kv (scoped storage), queue (message queue), runtime (wasmtime instance management), sandbox (rate limiting, quota enforcement, URL allowlisting).

bext-plugin-v8

V8 isolate sandbox for plugin JS.

First-class plugin tier sharing the same V8 engine the SSR pipeline uses (so no extra runtime to ship). Pinned-thread-per-isolate threading model, fuel-via-watchdog preemption, JSON-over-host-functions ABI. See V8 plugins.

bext-plugin-quickjs

QuickJS interpreter sandbox.

Optimized for tiny footprint and deterministic interpretation. Modules: api (JS global registration — console, bext.storage, bext.fetch, bext.config, bext.metric), runtime (QuickJS runtime with memory limits, stack limits, and interrupt-based timeout enforcement).

bext-plugin-lua

Lua 5.4 plugin runtime.

For middleware authors who prefer Lua. Sandboxed via mlua's safe-mode and a host-function table similar to the V8 binding.

bext-plugin-nsjail

Process-level sandbox with JSON-over-stdio IPC.

Modules: config (interpreter detection from shebang/extension), ipc (JSON line protocol with 10 MB max line length), runtime (child process management), sandbox (Linux namespace setup when available).

Networking + protocols

bext-tls

Automatic TLS certificate provisioning and management.

Key types: AcmeClient (Let's Encrypt / ZeroSSL), SniCertResolver (multi-domain SNI), OcspStapler (background OCSP stapling), RenewalManager (automatic renewal), CertStore (SQLite-backed storage), OnDemandProvisioner (provision on first request), MtlsConfig (mutual TLS client certs).

bext-realtime

SSE and WebSocket pub/sub hub.

Key types: BextHub (central broker), TopicAuth (per-topic authorization rules), SseStream, WsSession, RedisRelay (requires redis feature).

bext-waf

Web Application Firewall.

Key types: WafDecision (Allow / Block / RateLimit / Challenge), WafRequest, RuleEngine (SQLi/XSS/traversal detection), IpFilter (CIDR lists), GeoBlocker, BotDetector, DdosGuard, EnhancedRateLimiter, WafAuditLog.

bext-ebpf

eBPF kernel-level acceleration.

Modules: xdp (packet filtering), tracing_probes (request waterfall uprobes), tcp (connection intelligence via sock_ops), seccomp (syscall allowlisting for plugin sandboxes), capability (Linux capability detection).

bext-php

Embedded PHP SAPI for in-process PHP execution.

Key types: PhpPool (thread pool of PHP workers), PhpState (top-level handle for AppState).

bext-protocol-mqtt

MQTT 5 gateway broker.

Topic routing, QoS 0/1/2, persistent sessions, retained messages. Bridges to bext-realtime so SSE/WebSocket clients can subscribe to the same topic namespace.

bext-protocol-grpc

First-party gRPC support.

tonic-based service registry, codec handling, gRPC-Web transcoding so browsers can call into the same services without a proxy layer.

bext-protocol-caldav

CalDAV / CardDAV protocol support.

WebDAV methods, iCalendar, vCard. Useful for CRM/calendar surfaces.

nginx compat

bext-nginx-compat

nginx.conf parser and converter.

Modules: lexer, ast (nginx config AST), convert (AST → bext config), detect (auto-detection of nginx.conf on disk). Powers "masquerade mode" where bext drops in for nginx with zero config changes on the operator side.

bext-nginx-shim

Drop-in nginx binary replacement.

Mimics the nginx command-line interface: PID file, SIGHUP reload, systemd override generation. Lets bext sit behind existing systemctl reload nginx workflows.

Framework adapters

Each adapter implements the FrameworkAdapter trait from bext-core. Detection looks at package.json / config files; build shells out to the framework's own CLI; serve runs the produced output through bext SSR or as a static-asset bundle.

PRISM is not a framework adapter — it's owned by bext-core (the compile pass) and bext-turbopack (the call sites). Next.js and Hono are handled inline in bext-server's SSR pipeline rather than via a crate adapter.

Tooling / DX

bext-dx

Developer-experience engine.

TOML format/lint, plugin/infra/route graph, env provenance, secret store. Shared by the bext CLI and bext-lsp.

bext-lsp

Language server for bext.config.toml.

Reuses bext-dx rules so VS Code, Zed, nvim and Helix all share one diagnostic engine. Completions, hovers, "go to plugin definition".

bext-tui

Terminal management dashboard.

Ratatui-based live-deploy / log-streaming UI. Useful for headless servers where you want to watch a deploy from a TTY.

bext-bench-history

Performance history store.

SQLite-backed perf-history database used by the benchmark dashboard and CI regression detector. Stores per-commit benchmark numbers (SSR µs/req, TTFB, bundle size, etc.) so regressions get caught before they ship.

Test harnesses

Live under harnesses/ (most are also workspace members so they share build artifacts):

Binary crates

Feature flag combinations

# Community (free) — minimal build, ~45s cold compile
cargo build --release -p bext-server --no-default-features

# Default — V8 + Turbopack + route-css + react-compiler
cargo build --release -p bext-server

# Pro — security + performance features
cargo build --release -p bext-server \
  --features "waf,h3-quic,redis,otel,plugins,nginx-compat,realtime,websocket-proxy"

# Enterprise — everything
cargo build --release -p bext-server --all-features

# Custom — pick what you need
cargo build --release -p bext-server --features "waf,redis,plugins"

A minimal build takes ~45 seconds on an M2 MacBook Pro. The full production build with v8 + turbopack + route-css + react-compiler + nginx-compat + tls + redis + realtime + waf + php + h3-quic takes ~5 minutes cold and ~30 seconds warm. See Architecture overview for the full feature-flag table.