The package registry

Enforced, build-failing performance budgets as code. The efficient path is the default one must opt out of — a dependency that quietly doubles a route's weight is caught at merge time, not in production.

Fine-grained reactivity — the settled model, adopted rather than reinvented. Network quality is simply another reactive input; signals compose naturally with resumability.

The render core: a branded VNode, an automatic JSX runtime, the island() boundary, and renderToString — which emits zero JavaScript and zero handlers for everything that is not an island.

The tiny client runtime: reactive DOM with no virtual DOM, on-demand island resumption, and opt-in resume-in-place hydration. The cost of becoming interactive is bounded by what the user actually touches.

A single, prescribed, convention-based file-system router — constraint-aware by default: prefetch tuned to network quality, offline-aware route resolution, and automatic per-route code-splitting that is budgeted.

The integrated server runtime — web-standard Request/Response. Renders with resumability, co-locates critical data with the initial document to collapse client waterfalls, and enforces budgets across the whole response.

The build pipeline: static generation, esbuild code-splitting into a shared runtime plus lazy island chunks, the asset pipeline, a service worker, and the budget / accessibility / module-boundary gates that fail the build.

The development server — Vite-powered middleware with Gomani SSR and HMR, serving islands and .goma templates from source with fast full reloads on app changes.

Network quality as application state — responsive design for the network, not the viewport. A defensive, multi-input signal drives text-first layouts, deferred imagery, and suppressed autoplay on constrained links.

Offline-first, local-first data with a built-in sync engine — the local device is the source of truth, the network opportunistic. Optimistic writes, an offline mutation queue, conflict-free merge, and encryption at rest.

The framework-owned asset pipeline — images, fonts, and media usually dominate bytes, so Gomani owns them: AVIF/WebP transcoding with network-aware sizing, per-route/per-locale font subsetting, and content-hashed URLs.

Mobile-money-first payments as a first-class, provider-agnostic concern. An idempotent engine (a dropped connection never double-charges), USSD/deep-link-aware flows, and a pass-through compliance posture that holds no funds.

Localization as a default — ICU message formatting, locale as a server-resolved signal (zero JavaScript, like adaptive), full RTL/bidi and non-Latin script support, and per-locale font subsetting that reconciles bytes with multilingualism.

Accessibility by default, and loud when it regresses — a build-time HTML audit that fails the build alongside the performance budget, plus accessible primitives so correct semantics are the starting point, not a retrofit.

Secure by default, especially offline — the shared, low-cost device threat model. AES-GCM encryption at rest with auth-derived keys, bounded-window offline sessions, and integrity-signed sync. Zero dependencies (Web Crypto).

Heavy media and 3D that degrades rather than breaks — 3D where the user can afford it, a representative image where they cannot. The framework owns the fidelity policy; the WebGL renderer is a pluggable seam.

One authoring model, many targets. PWA-first (installable, offline, updatable without a full re-download), an optional native shell for store presence, and a compile-to-native path reserved as a deliberate escalation.

The Savanna design system as zero-runtime CSS and design tokens — the cheapest beautiful interface. It ships no styling JavaScript and needs no hydration for appearance; using the design system and shipping fewer bytes become the same action.

The .goma compile-time template DSL — structure in a compiler-owned template, logic and reactivity in TypeScript signals, and the island boundary as a keyword. It makes zero-JavaScript-by-default and island isolation provable, with full type-checking inside templates.

Fault isolation and graceful degradation as primitives — bulkheads, circuit breakers, retries with jitter, timeouts, and degraded-mode contracts. Chase fault isolation, not microservices: one authoring surface, a topology spectrum.

A build-time module-boundary gate. Each app/module has one legal public import surface; deep imports into another module's internals, forbidden dependencies, and cycles fail the build with a located error.

A durable job queue, workers, and cron for the workload-class split — the web enqueues latency-safe, a separate worker drains. Local-default stores (memory/file), with Postgres/Redis as documented drop-ins.

The proof-of-thesis benchmark harness — a framework-agnostic static probe (eager-JS closure, HTML, CSS in Brotli bytes) plus a Playwright-gated runtime probe. Reports measured numbers only; never fabricates.

The Gomani CLI (bin: gomani). One command drives the whole lifecycle: dev, build, start, budget, boundaries, worker, bench, and scaffolding — heavy packages are lazily imported so `gomani budget` stays light.

The scaffolder behind `npm create gomani` — a starter with a static page, an island, the Savanna design system, an accessibility-clean build, an enforced size budget, and an installable, offline PWA out of the box.