Everything the compiler does, written down.

What Vesk is, what .vsk files look like, how to scaffold a project, and the commands that drive the compiler.

The component keyword, typed params, generics, async and island modifiers, and the two body modes.

import * as NS from './card.vsk' and <NS.Card /> — the namespace is a compile-time shorthand, not a value.

The &[] sugar for creating reactive cells: auto-tracked bindings, raw-cell bindings, and how the compiler rewrites reads and writes.

Tracked cells, the cell API, microtask-batched scheduling, effects, and the flushSync/tick escapes. No virtual DOM.

The classic component body style: a single return <jsx> at the end, with guard clauses, .map() lists and ternaries before it.

Markup and control flow directly as statements: bare JSX, if/for/while/switch/try, guard-clause returns, and for-key/index clauses.

Server-first rendering, the client island modifier, {#client}/{#server} blocks, and which blocks a component kind may use.

Component-scoped CSS via a <style> element in the body, how it is extracted, and how it is emitted on server and client.

The built-in <Md> component and renderMarkdown(): tokenizer-based, with highlighting, GFM, streaming, and configurable HTML policies.

vesk.config.js / vesk.config.ts, defineConfig and how it normalizes security, environment loading, platforms, and the app-level events + context system.

Explicit non-features. Vesk is a TypeScript superset — everything listed here is intentionally absent today, and the absence is a contract.

Four stages, no hidden runtime: preprocess, parse, IR generation, and codegen to server and client JavaScript (or Kotlin).

The ephemeral typed IR: a class hierarchy in ir.ts, consumed by the server and client codegen visitors and by vesk-native-compiler.

How the client codegen distinguishes fully-static subtrees from reactive ones, and how hydrate-mode markers work.

The compiler's answer to the client/server boundary: the needsClient check, per-block validation, and per-target stripping.

VeskError, HttpError, TimeoutError and NotFoundError, plus error handling in components and server code.

Two routing modes — file-based under app/ and manual via createRouter — with dynamic segments and catch-alls, nested layouts, loading/error/not-found/offline pages, Link/NavLink navigation, prefetching, guards, and the low-level router API.

useFetch and its static variants, createResource, mutate, HttpError / TimeoutError, and SSR data handoff.

The reactive primitive: a cell you read, write and subscribe to — with a binding you use like a plain variable.

A computed cell: recomputes only when something it reads changes, and reads like a plain value once unwrapped.

Reaching past the binding to the raw cell: get, set, and the reads that deliberately do not subscribe.

Run a side effect when the cells it reads change — and nothing else. Client-only, ordered after render, cleaned up for you.

When writes actually reach the DOM: flushSync, tick, and what batches for you.

Render one branch or another with no wrapper element — the conditional that costs no DOM node.

Rendering lists server-side: the native for loop (keyed) and the For component, and when to use which.

First-match branching with components instead of else-if chains.

How Vesk attaches client behavior to server-rendered HTML: vsk markers, claim walkers, and the hydration entry points.

The Form and Field components, validation rules, and server actions with defineAction, validateActionInput and issuesToFieldMap.

Server-side endpoints under app/api/: route conventions, method handler exports, dynamic segments, body parsing, validation and VeskResponse.

fn(ctx, next) middleware, the MiddlewareContext, next(rewrite), building responses, and examples for logging, auth, CORS and rewriting.

Page-, component- and data-level ISR with stale-while-revalidate, page config via export const, and targeted invalidation by path, tag or component.

Request context (useParams/useRequest/useBody), cookies(), headers(), locals(), VeskRequest / VeskResponse / ServerResponse, CORS, webhooks, hooks, validation, signed cookies and server events.

Declare a route's title, description, Open Graph and alternates as data, with a static head that does not depend on the component's frame.

Titles and descriptions via defineMetadata, structured data via the JsonLd component and schema generators, plus vesk seo to audit your app.

Reactive browser network state: getNetworkState with online, effectiveType, downlink, rtt, saveData, plus watchNetwork subscriptions.

bindValue, bindChecked and bindGroup for wiring tracked cells to DOM form elements.

Image, Portal, Experiment and LoadingIndicator — all auto-imported from @vesk/runtime.

Show, For, Switch and Match — composable render helpers with no markup and no styling.

Author components outside .vsk files: primitive() for presentational components that return markup, leaf() for stateful and async widgets — both callable as <Badge/> or Badge().

The runtime reactivity engine: cells, the microtask scheduler, block trees, scoped flushing, and the flushSync/tick escapes.

The reconcile function: keyed list updates that operate directly on the real DOM with comment markers — no virtual DOM.

One SSR function + one client bundle, platform targets, the Node server, SSR rendering rules, and the browser bundle.

A centralized reactive store with optional persistence, middleware, and derived stores.

Compile .vsk components to Kotlin with Jetpack Compose and Material 3 — real Android views, real platform APIs, no WebView.

Scaffold a native Android app with create-vesk-native, install the toolchain, write your first .vsk page, and build an APK.

File-based and manual routing in vesk-native: layout/page conventions, dynamic params, manual routes in veskconfig.ts, Link/NavLink/Outlet, and programmatic navigation.

The full veskconfig.ts reference for native apps: identity, SDK targets, theme, back behavior, edge-to-edge, deep links, icon, splash, signing, and bundling.

The device.* API surface, the three access patterns (state bindings, callbacks, markup elements), the permission mapping tables, and every tangible element tag.

How browser and web-platform APIs compile to native Kotlin: fetch, WebSocket, EventSource, storage, sqlite, auth, JS semantics, and the platform seam.

PullToRefresh, SwipeToDismiss, CardStack, Link, NavLink, and Outlet — the Material3-backed framework components emitted as native composed calls.

motion.animate() and friends in native: MotionRef, spring and tween easing mapped to Compose, motionInView, and connected interrupts.

The .vsklib library system: libraries.json, the curated registry, vesk add/install/update/remove, auto-generated bindings, and using Kotlin libraries from .vsk.

The three vesk-native dev loops: on-device fast reload, the desktop JVM preview with Compose Hot Reload, and the web browser preview with the device.* shim.

Release signing and packaging for Android (AAB + APK) and iOS (Xcode project + .ipa): signing config, pre-flight checks, secrets via env:, export methods, and Play/App Store requirements.

The @vesk/native-compiler surface: compileVsk, compileVskResult, CompileOptions, targets, JS/TS module compilation, and Kotlin codegen behavior.

Every vesk-native command: init, build, bundle, verify, setup, update-tools, dev, and the library verbs (add, install, update, remove).

The full vesk CLI: dev, build, start, typecheck, seo, init — flags, defaults, config loading, dev server behaviors, HMR messages and build output.

The VeskPlugin shape, definePlugin, every real hook, provides, registration and validation, and how @vesk/plugin-tailwind integrates.

@vesk/lsp provides LSP support for .vsk files: diagnostics, autocomplete, go to definition, hover and find references.

VS Code and Neovim/Vim plugins for .vsk files — syntax highlighting and the bundled LSP server, no build step.

Install the `vesk` and `react-to-vesk` skills into your AI coding tool so agents reference the current Vesk API, not training data.

@vesk/prettier-plugin formats .vsk files in Prettier, preserving component, &[] and {#server}/{#client} syntax.