# Foldkit

> Foldkit is a TypeScript frontend framework built on Effect-TS that uses The Elm Architecture: a single Model, pure update, and side effects confined to Commands.

This index lists every page on the Foldkit documentation site with a short description. Every page is also available as Markdown by appending `.md` to its URL (e.g. https://foldkit.dev/get-started.md). A single-file concatenation of every page is available at https://foldkit.dev/llms-full.txt.

When to use Foldkit:

- Building a browser single-page application in TypeScript around The Elm Architecture: one Schema-defined Model, Messages as facts, a pure update function, and side effects confined to Commands.
- Extending a codebase that already uses Effect-TS, since Foldkit shares its idioms (Effect, Schema, Match, Option) and its ecosystem.
- Applications where agents write or audit significant code. Explicit state transitions and Messages-as-data make programs inspectable, and the Story and Scene test frameworks drive them without a browser.
- Not a fit for: server-only projects with no browser UI, teams staying on React and JSX idioms, or codebases avoiding the Effect ecosystem.

How an agent works with Foldkit:

- Scaffold a new application with `npm create foldkit-app@latest` (pnpm, yarn, and bun equivalents work too).
- Fetch any page below as Markdown by appending `.md` to its URL, or by requesting the page URL with `Accept: text/markdown`.
- Connect to a running app through the DevTools MCP server (`npx @foldkit/devtools-mcp init`) to inspect the Model, replay history, and dispatch Messages.
- Install the repository skills from https://foldkit.dev/ai/skills for architecture guidance, program generation, and application audits.

## Developer Resources

- [llms-full.txt](https://foldkit.dev/llms-full.txt): Every documentation page concatenated into one Markdown file.
- [Content API documentation](https://foldkit.dev/api): The read-only JSON API for this site: endpoints, authentication, versioning and deprecation policy, rate limit headers, and the error model.
- [Content API service index](https://foldkit.dev/api/v1): The endpoint list and policies as JSON. Pages, sections, examples, and blog posts hang off it.
- [openapi.json](https://foldkit.dev/openapi.json): OpenAPI 3.1 description of this site's machine-readable content endpoints, with a typed schema for every response.
- [Sitemap](https://foldkit.dev/sitemap.xml): Every page URL on the site.
- [AI overview](https://foldkit.dev/ai/overview): How Foldkit's explicit architecture supports coding agents, and the resources available to them.
- [Agent skills](https://foldkit.dev/ai/skills): Installable repository skills for architecture guidance, program generation, and application audits.
- [DevTools MCP server](https://foldkit.dev/ai/mcp): Connect an agent to a running Foldkit application. Published on npm as @foldkit/devtools-mcp.
- [GitHub repository](https://github.com/foldkit/foldkit): Source code, issues, and discussions.
- [Blog RSS feed](https://foldkit.dev/blog/rss.xml): Release announcements and deep dives.
- [About](https://foldkit.dev/about): What Foldkit is, who builds it, and how it is released.
- [Contact](https://foldkit.dev/contact): Issues, chat, security reports, and contributions.
- [Privacy](https://foldkit.dev/privacy): What this site collects and what stays in your browser.

## Docs

- [Coming from React](https://foldkit.dev/react/coming-from-react): See how Foldkit replaces component-owned state and Effects with one Model, Messages, update, Commands, Subscriptions, and Submodels.
- [Coming from TanStack Query](https://foldkit.dev/react/coming-from-tanstack-query): Foldkit has no useQuery. AsyncData models remote values, while caching, refetching, invalidation, deduplication, and request races remain visible application policy.
- [Field Validation](https://foldkit.dev/core/field-validation): Model each field as NotValidated, Validating, Invalid, or Valid. Compose synchronous and asynchronous Rules, cross-field checks, and form-level validation.
- [Get Started](https://foldkit.dev/get-started): Create a Foldkit project from a starter, inspect the generated structure, or add Foldkit to an existing Vite application.
- [Project Organization](https://foldkit.dev/patterns/project-organization): Start with one main module, then separate Messages, Commands, Submodels, and Subscriptions when ownership or file size makes the split useful.
- [Roadmap](https://foldkit.dev/introduction/roadmap): Where Foldkit is today, how it got here, the work remaining before 1.0, and the architectural promises that will not change.
- [Routing & Navigation](https://foldkit.dev/core/routing-and-navigation): Define routes with bidirectional parser combinators that decode URLs into typed values and build URLs from Schema-validated parameters.
- [Testing](https://foldkit.dev/testing): Test Foldkit programs with Story and Scene. Story drives the update loop directly, while Scene drives the rendered view through accessible locators.
- [Why Foldkit](https://foldkit.dev/introduction/why-foldkit): Why Foldkit exists and the principles behind its design.

## Guides

- [Foldkit vs Elm: Side by Side](https://foldkit.dev/elm/foldkit-vs-elm-side-by-side): A side-by-side comparison of the same pixel art editor built in both Foldkit and Elm. Same architecture, different host: ports vs Commands, decoders vs Schema, and what each side gives up.
- [Foldkit vs React + Effect Atom](https://foldkit.dev/react/foldkit-vs-react-effect-atom): Two Effect-native architectures: Effect Atom distributes state across reactive cells inside React, while Foldkit builds the application around one Model and update function.
- [Foldkit vs React: Side by Side](https://foldkit.dev/react/foldkit-vs-react-side-by-side): A side-by-side comparison of the same pixel art editor built in both Foldkit and React. Covers state management, side effects, testing, performance, and architectural tradeoffs.

## Core Concepts

- [Architecture](https://foldkit.dev/core/architecture): How Model, Messages, update, view, Commands, Subscriptions, and the Runtime form Foldkit’s Elm Architecture loop.
- [Async Data](https://foldkit.dev/core/async-data): A six-state value type for asynchronously loaded data in the Model: Idle, Loading, Refreshing, Failure, Stale, and Success, with stale-while-revalidate and keep-stale-on-failure built in.
- [Canvas](https://foldkit.dev/core/canvas): Declarative 2D rendering with a Schema-defined Shape AST and pointer events translated to canvas-local coordinates.
- [Commands](https://foldkit.dev/core/commands): Describe one-shot Effects caused by Messages, map their results back into Messages, test them as values, and interrupt keyed work when needed.
- [Counter Example](https://foldkit.dev/core/counter-example): Build and trace a minimal Counter through its Model, Message Schema, update, view, init, and Runtime wiring.
- [Crash View](https://foldkit.dev/core/crash-view): Replace the default Runtime crash screen and report unrecoverable failures without treating expected Effect failures as crashes.
- [CustomElement](https://foldkit.dev/core/custom-element): Create typed Foldkit builders for native custom elements by declaring their properties and CustomEvents with Schema.
- [DevTools](https://foldkit.dev/core/devtools): Inspect Message history, Model changes, Commands, and Mounts in the development overlay. Configure time travel, filtering, history limits, and AI dispatch.
- [Dom](https://foldkit.dev/core/dom): Use Effects for common DOM work such as focus, dialog control, scrolling, scroll locks, and inert isolation.
- [Embedding](https://foldkit.dev/core/embedding): Embed a Foldkit widget in another application through a Schema-typed handle. Covers initial Flags, inbound and outbound Ports, disposal, and React integration.
- [File](https://foldkit.dev/core/file): Read and select browser files through an opaque File type, with event attributes for native inputs and drop zones.
- [Freeze Model](https://foldkit.dev/core/freeze-model): Deep-freeze the Model in development to catch accidental mutation at the write site. Covers what is frozen and the Runtime cost.
- [Http](https://foldkit.dev/core/http): Provide a Fetch-backed HttpClient to Commands while keeping browser requests CORS-simple by disabling trace header propagation unless it is required.
- [Init & Flags](https://foldkit.dev/core/init-and-flags): Construct the first Model and startup Commands. Routing supplies the current URL, while Schema-validated Flags support fresh client boots and hydration.
- [Machine](https://foldkit.dev/core/machine): Model multi-state workflows as typed transition tables with guards, shared Edges, update integration, structural analysis, and pure tests.
- [Managed Resources](https://foldkit.dev/core/managed-resources): Acquire a stateful handle while a Model condition holds, expose it to Commands, and release it when dependencies change. Covers Layers and Submodel lifting.
- [Messages](https://foldkit.dev/core/messages): Define the facts update can handle as a Schema-backed Message union, with naming conventions for user actions, Command results, and Submodel wrappers.
- [Model](https://foldkit.dev/core/model): Define application state as one Schema-backed Model. Foldkit uses its runtime Schema to preserve state across hot updates and validate unknown data.
- [Mount](https://foldkit.dev/core/mount): Run DOM work while a specific rendered element exists. Mount supplies the live Element, emits declared result Messages, and keeps setup paired with cleanup.
- [Preserve Scroll](https://foldkit.dev/core/preserve-scroll): Restore window scroll position across Vite HMR reloads. Covers when restoration runs and its window-only scope.
- [Render](https://foldkit.dev/core/render): Synchronize Commands and Effects with the browser render cycle so DOM reads and CSS transitions land on the intended frame.
- [Resources](https://foldkit.dev/core/resources): Provide app-lifetime Effect services to Commands, Subscriptions, Mounts, and Flags, or provide a service directly when sharing is unnecessary.
- [Runtime](https://foldkit.dev/core/runtime): Configure a page-owning application with makeApplication, or mount a reusable widget with makeElement and embed.
- [Server Rendering](https://foldkit.dev/core/server-rendering): Render the same application to HTML for request-time SSR or build-time SSG, then hydrate it in place through a validated build-id and Flags handoff.
- [Slow Warnings](https://foldkit.dev/core/slow-warnings): Measure development-mode update, view, patch, and Subscription dependency phases, interpret warnings, and tune thresholds after profiling.
- [Submodel](https://foldkit.dev/core/submodel): Split a large application into child state machines while preserving parent-to-child Message flow. Covers Update.foldChild, h.submodel, OutMessages, reflection, testing, and DevTools.
- [Subscriptions](https://foldkit.dev/core/subscriptions): Run ongoing Streams whose lifetime follows Model-derived dependencies. Covers restart behavior, timers, browser events, live dependency reads, and Submodel lifting.
- [Update](https://foldkit.dev/core/update): Handle every Message with a pure update function that returns the next Model and Commands. Use Match and evo to keep transitions exhaustive and immutable.
- [View](https://foldkit.dev/core/view): Return a Document or Html value as a pure function of the Model. Covers document metadata, element builders, events, and view decomposition.
- [View Memoization](https://foldkit.dev/core/view-memoization): Skip stable view subtrees with createLazy and createKeyedLazy, choose cache keys by entity identity, and profile before adding memoization.
- [View Transitions](https://foldkit.dev/core/view-transitions): Animate qualifying renders with the browser View Transitions API. Covers route direction, shared elements, and when a running transition is skipped.

## Best Practices

- [Immutability](https://foldkit.dev/best-practices/immutability): Update Models immutably with evo, preserving references for unchanged branches and keeping state transitions predictable.
- [Keying](https://foldkit.dev/best-practices/keying): Use stable Model identifiers to preserve identity for mapped list items and entities rendered at one position.
- [Messages](https://foldkit.dev/best-practices/messages): Name Messages as verb-first, past-tense facts, and name Command result Messages after the Command that produced them.
- [Side Effects & Purity](https://foldkit.dev/best-practices/side-effects-and-purity): Keep update and view deterministic by confining outside work to Commands, Subscriptions, Mounts, ManagedResources, and other Runtime-managed boundaries.

## Patterns

- [Informing Submodels](https://foldkit.dev/patterns/informing-submodels): Relay a change a Submodel does not own (a URL, a server push, an auth change) through a helper it exposes, so it can update its own state in response.
- [Subscription Organization](https://foldkit.dev/patterns/subscription-organization): Organize Subscription records by ownership and lift child Subscriptions through nested Model and Message types.

## Tooling

- [Oxlint Plugin](https://foldkit.dev/tooling/oxlint-plugin): Install and configure @foldkit/oxlint-plugin, then see what each Foldkit-specific rule accepts and rejects.

## FAQ

- [Performance](https://foldkit.dev/faq/performance): Foldkit’s rendering cost model, TodoMVC benchmark results, development-mode overhead, and the tools for measuring and memoizing expensive views.

## Foldkit UI

- [Anchor](https://foldkit.dev/ui/anchor): Position and portal floating panels with the same Floating UI runtime used by Listbox, Combobox, Menu, Popover, Tooltip, and Date Picker.
- [Animation](https://foldkit.dev/ui/animation): Coordinates CSS enter/leave animations via a state machine and data attributes. Works with both CSS transitions and keyframe animations.
- [Button](https://foldkit.dev/ui/button): A stateless wrapper around the native button with accessibility attributes, event wiring, and styling hooks.
- [Calendar](https://foldkit.dev/ui/calendar): Accessible inline calendar grid with 2D keyboard navigation, locale-aware headers, and min/max/disabled-date constraints.
- [Checkbox](https://foldkit.dev/ui/checkbox): Accessible checkbox with indeterminate state support.
- [Combobox](https://foldkit.dev/ui/combobox): A searchable selection Submodel with parent-controlled filtering, single-select and multi-select modes, and anchored positioning.
- [Date Picker](https://foldkit.dev/ui/date-picker): An accessible Date Picker that wraps Calendar in a Popover, with focus management, click-outside dismissal, and a hidden input for native form submission.
- [Dialog](https://foldkit.dev/ui/dialog): A modal dialog backed by the native dialog element with focus trapping and scroll locking.
- [Disclosure](https://foldkit.dev/ui/disclosure): A stateless, controlled show-and-hide helper for inline content, with disclosure semantics and keyboard behavior.
- [Drag and Drop](https://foldkit.dev/ui/drag-and-drop): Accessible drag and drop with keyboard support, auto-scrolling, and screen reader announcements.
- [Fieldset](https://foldkit.dev/ui/fieldset): A stateless wrapper around the native fieldset with linked legend and description attributes.
- [File Drop](https://foldkit.dev/ui/file-drop): Headless file drop zone that accepts drag-and-drop plus click-to-browse via a hidden native file input.
- [Foldkit UI](https://foldkit.dev/ui/overview): Choose between stateful Submodels and stateless render helpers in Foldkit’s headless UI package. Covers accessibility, styling, installation, and the component catalog.
- [Hover Intent](https://foldkit.dev/ui/hover-intent): Behavior-only Submodel for delayed hover and focus reveal across a trigger and panel.
- [Input](https://foldkit.dev/ui/input): A thin wrapper around the native input with ARIA linking and styling hooks.
- [Listbox](https://foldkit.dev/ui/listbox): A selection Submodel with single-select and multi-select modes, keyboard navigation, typeahead, and anchored positioning.
- [Menu](https://foldkit.dev/ui/menu): An anchored action-menu Submodel with keyboard navigation, typeahead, dismissal, and optional modal behavior.
- [Nav](https://foldkit.dev/ui/nav): A stateless helper for URL-driven navigation with aria-current page semantics.
- [Popover](https://foldkit.dev/ui/popover): An anchored floating panel for arbitrary content, with dismissal, focus return, portaling, and optional modal behavior.
- [Radio Group](https://foldkit.dev/ui/radio-group): A selection Submodel for radio options, with roving tabindex, keyboard navigation, and read-only behavior.
- [Select](https://foldkit.dev/ui/select): A stateless wrapper around the native select with ARIA linking, change handling, and styling hooks.
- [Selection Submodels](https://foldkit.dev/ui/selection-submodels): Use create<Item>() factories to keep one item type across a selection Submodel’s view, update, programmatic helpers, and OutMessages.
- [Slider](https://foldkit.dev/ui/slider): A numeric range Submodel with pointer dragging, keyboard navigation, constraints, steps, and ARIA slider semantics.
- [Switch](https://foldkit.dev/ui/switch): A stateless, controlled toggle for immediate on-and-off actions, with keyboard behavior and switch semantics.
- [Tabs](https://foldkit.dev/ui/tabs): A selection Submodel for tab panels, with roving tabindex, horizontal and vertical orientation, and automatic or manual activation.
- [Textarea](https://foldkit.dev/ui/textarea): A thin wrapper around the native textarea with ARIA linking and styling hooks.
- [Toast](https://foldkit.dev/ui/toast): Stack of transient notifications anchored to a corner of the viewport with per-entry enter/leave animations and auto-dismiss.
- [Tooltip](https://foldkit.dev/ui/tooltip): Non-interactive floating label that appears on hover or focus and hides on leave, blur, or Escape.
- [Virtual List](https://foldkit.dev/ui/virtual-list): Render only visible rows plus overscan while spacers preserve scroll geometry. Supports fixed and variable row heights, measurement, and programmatic scrolling.

## Testing

- [Scene](https://foldkit.dev/testing/scene): Drive the rendered VNode tree with accessible locators, dispatch interactions, resolve lifecycle results, and assert on the resulting HTML.
- [Story](https://foldkit.dev/testing/story): Drive update with Messages, inspect the Model and Commands, and supply Command results without executing their Effects.

## Examples

- [API Cache](https://foldkit.dev/example-apps/api-cache): Query caching without a query client. Demonstrates stale-while-revalidate, request deduplication, invalidation, and interval refetching.
- [Auth](https://foldkit.dev/example-apps/auth): An authentication flow with Submodels, OutMessage, protected routes, and session management.
- [Canvas Art](https://foldkit.dev/example-apps/canvas-art): Click the canvas to spawn bouncing balls. Demonstrates declarative 2D rendering with Canvas.view, animation-frame Subscriptions, and pointer events translated to canvas-local coordinates.
- [Charting](https://foldkit.dev/example-apps/charting): A live dashboard for public Foldkit telemetry from GitHub and npm. Demonstrates HTTP Commands, asynchronous state, an ECharts Mount adapter, and a Subscription that turns chart clicks into Messages.
- [Counter](https://foldkit.dev/example-apps/counter): The classic counter example. Increment, decrement, and reset a number.
- [Counters](https://foldkit.dev/example-apps/counters): Add and remove independent Counter Submodels in a dynamic list. Each row is embedded through h.submodel and routed through a wrapper Message.
- [Crash View](https://foldkit.dev/example-apps/crash-view): A custom crash fallback with a button that crashes the application and an action that reloads it. Demonstrates crash.view and crash.report.
- [Embedding](https://foldkit.dev/example-apps/embedding): A Foldkit widget embedded in a plain TypeScript host page through Runtime.embed. The host seeds initial state with Flags, pushes a step value in through an inbound Port, mirrors the count the widget emits through an outbound Port, and mounts and unmounts the widget with dispose. All communication crosses one Schema-typed handle; the host never touches the Model.
- [Examples](https://foldkit.dev/example-apps): Browse working Foldkit applications that cover state, forms, routing, caching, authentication, server rendering, UI components, third-party integrations, and more.
- [Form](https://foldkit.dev/example-apps/form): A form with field validation, error states, and asynchronous submission.
- [Generative Art](https://foldkit.dev/example-apps/generative-art): Move the mouse to stir a Perlin-noise flow field, then click to bloom prismatic particle bursts. Demonstrates Canvas.view with hundreds of evolving Path strokes per frame, Effect Random for spawning, and simulation controls wired through Messages.
- [Interrupting Commands](https://foldkit.dev/example-apps/interrupting-commands): Simulated file uploads driven by interruptible Commands. Cancel one upload, cancel every upload in flight, or restart a cancelled upload through a keyed interrupt registry and an outcome-carrying result Message.
- [Job Application](https://foldkit.dev/example-apps/job-application): A multi-step form with asynchronous email validation, cross-field date constraints, file uploads, and per-step error indicators.
- [Kanban](https://foldkit.dev/example-apps/kanban): A drag-and-drop kanban board with cross-column reordering, keyboard navigation, fractional indexing, and screen reader announcements.
- [Managed Resource Layer](https://foldkit.dev/example-apps/managed-resource-layer): A layer-backed ManagedResource starts a ComputeEngine service from an Effect Layer, exposes it to Commands, and runs Layer finalizers when the Model turns it off.
- [Map](https://foldkit.dev/example-apps/map): An interactive MapLibre GL map with locations, search, and "find my location." Demonstrates a Mount integration with a third-party DOM library, plus a Subscription that turns map movement and marker clicks into Messages.
- [Personal Blog](https://foldkit.dev/example-apps/personal-blog): A blog whose prose lives in Markdown files. The @foldkit/markdown Vite plugin compiles each file into a typed document, per-node view overrides style the result, and directive islands place a live Counter Submodel and Note callout between paragraphs.
- [Pixel Art](https://foldkit.dev/example-apps/pixel-art): A pixel art editor with immutable undo and redo, time-travel history, Foldkit UI components, lazy views, Subscriptions, Commands that report errors as Messages, and localStorage persistence through Flags.
- [Query Sync](https://foldkit.dev/example-apps/query-sync): A filterable dinosaur table where every control syncs to URL query parameters. Schema transforms accept valid states and replace invalid parameters with declared defaults.
- [Route Transitions](https://foldkit.dev/example-apps/route-transitions): A live log shows which Transition helper handles each navigation. Entering the gallery loads its catalog once, staying on a painting refetches only when its id changes, and leaving the studio saves a draft.
- [Routing](https://foldkit.dev/example-apps/routing): A client-routed application with URL parameters, nested routes, rest segments, and navigation.
- [Server-Side Rendering](https://foldkit.dev/example-apps/ssr): A server renders each request into HTML using Flags read from a cookie, and the client hydrates with the exact values the server used. Reload the page and your latest count arrives already in the markup, before any JavaScript runs.
- [Shopping Cart](https://foldkit.dev/example-apps/shopping-cart): An e-commerce application with a product listing, cart management, and checkout flow.
- [Slow Warnings](https://foldkit.dev/example-apps/slow-warnings): Trigger slow update, view, patch, and Subscription dependency warnings at their default thresholds, then inspect them in a visible log.
- [Snake](https://foldkit.dev/example-apps/snake): The classic snake game. Keyboard input, game loop, and collision detection.
- [State Machine](https://foldkit.dev/example-apps/state-machine): A checkout workflow powered by the experimental state machine module. Guards skip Shipping for digital orders, gate Place order behind a complete review, and parse promo codes into applied discounts.
- [Static Site Generation](https://foldkit.dev/example-apps/ssg): A build script renders every route to static HTML through a server entry, and the client hydrates the served markup in place. The same init, view, and Model produce the build output and the running application.
- [Stopwatch](https://foldkit.dev/example-apps/stopwatch): A stopwatch with start, stop, and reset. Demonstrates a time-based Subscription.
- [Todo](https://foldkit.dev/example-apps/todo): A todo list persisted in localStorage. Add, complete, and delete tasks.
- [Typing Terminal](https://foldkit.dev/example-apps/typing-terminal): A production multiplayer typing game with a full-stack Effect RPC backend, streaming room Subscriptions, and a Foldkit frontend. Client and server share the same Schemas.
- [UI Showcase](https://foldkit.dev/example-apps/ui-showcase): An interactive showcase of every Foldkit UI component, with styled routed demos and their parent and Submodel wiring.
- [View Transitions](https://foldkit.dev/example-apps/view-transitions): Animated route changes with the View Transitions API. Transition types control direction-aware slides, and a shared element morphs from gallery card to detail hero.
- [Weather](https://foldkit.dev/example-apps/weather): Look up weather by ZIP code. Demonstrates HTTP requests and loading states.
- [Web Components](https://foldkit.dev/example-apps/web-components): A QR code designer integrates two third-party web components through CustomElement.define. The color picker emits CustomEvents as Messages, the QR element receives typed properties, and both communicate through the Model.
- [WebSocket Chat](https://foldkit.dev/example-apps/websocket-chat): A ManagedResource owns a WebSocket connection lifecycle. Demonstrates connection state, reconnection, and frames entering update as Messages.

## AI

- [AI](https://foldkit.dev/ai/overview): How Foldkit’s explicit architecture gives coding agents stable boundaries, plus the source, skills, and DevTools MCP references available to them.
- [DevTools MCP](https://foldkit.dev/ai/mcp): Connect an agent to a running Foldkit application to inspect Models and Message history, compare states, replay the UI, and dispatch Schema-validated Messages.
- [Foldkit Content API](https://foldkit.dev/api): The read-only JSON API for this documentation site: endpoints, authentication, versioning and deprecation policy, rate limit headers, and the RFC 9457 error model.
- [Skills](https://foldkit.dev/ai/skills): Install and use Foldkit’s repository skills for architecture guidance, program generation, and application audits.

## API Reference

- [AsyncData](https://foldkit.dev/api-reference/async-data): API documentation for the AsyncData module.
- [Calendar](https://foldkit.dev/api-reference/calendar): API documentation for the Calendar module.
- [Canvas](https://foldkit.dev/api-reference/canvas): API documentation for the Canvas module.
- [Command](https://foldkit.dev/api-reference/command): API documentation for the Command module.
- [Command/Interruptible](https://foldkit.dev/api-reference/command-interruptible): API documentation for the Command/Interruptible module.
- [CustomElement](https://foldkit.dev/api-reference/custom-element): API documentation for the CustomElement module.
- [Dom](https://foldkit.dev/api-reference/dom): API documentation for the Dom module.
- [Experimental/Machine](https://foldkit.dev/api-reference/experimental-machine): API documentation for the Experimental/Machine module.
- [Experimental/Server](https://foldkit.dev/api-reference/experimental-server): API documentation for the Experimental/Server module.
- [FieldValidation](https://foldkit.dev/api-reference/field-validation): API documentation for the FieldValidation module.
- [FieldValidation/Rule](https://foldkit.dev/api-reference/field-validation-rule): API documentation for the FieldValidation/Rule module.
- [File](https://foldkit.dev/api-reference/file): API documentation for the File module.
- [Html](https://foldkit.dev/api-reference/html): API documentation for the Html module.
- [Http](https://foldkit.dev/api-reference/http): API documentation for the Http module.
- [ManagedResource](https://foldkit.dev/api-reference/managed-resource): API documentation for the ManagedResource module.
- [Message](https://foldkit.dev/api-reference/message): API documentation for the Message module.
- [Mount](https://foldkit.dev/api-reference/mount): API documentation for the Mount module.
- [Navigation](https://foldkit.dev/api-reference/navigation): API documentation for the Navigation module.
- [Port](https://foldkit.dev/api-reference/port): API documentation for the Port module.
- [Render](https://foldkit.dev/api-reference/render): API documentation for the Render module.
- [Route](https://foldkit.dev/api-reference/route): API documentation for the Route module.
- [Route/Transition](https://foldkit.dev/api-reference/route-transition): API documentation for the Route/Transition module.
- [Runtime](https://foldkit.dev/api-reference/runtime): API documentation for the Runtime module.
- [Scene](https://foldkit.dev/api-reference/scene): API documentation for the Scene module.
- [Schema](https://foldkit.dev/api-reference/schema): API documentation for the Schema module.
- [Story](https://foldkit.dev/api-reference/story): API documentation for the Story module.
- [Struct](https://foldkit.dev/api-reference/struct): API documentation for the Struct module.
- [Submodel](https://foldkit.dev/api-reference/submodel): API documentation for the Submodel module.
- [Subscription](https://foldkit.dev/api-reference/subscription): API documentation for the Subscription module.
- [Ui/Anchor](https://foldkit.dev/api-reference/ui-anchor): API documentation for the Ui/Anchor module.
- [Ui/Animation](https://foldkit.dev/api-reference/ui-animation): API documentation for the Ui/Animation module.
- [Ui/Button](https://foldkit.dev/api-reference/ui-button): API documentation for the Ui/Button module.
- [Ui/Calendar](https://foldkit.dev/api-reference/ui-calendar): API documentation for the Ui/Calendar module.
- [Ui/Checkbox](https://foldkit.dev/api-reference/ui-checkbox): API documentation for the Ui/Checkbox module.
- [Ui/Combobox](https://foldkit.dev/api-reference/ui-combobox): API documentation for the Ui/Combobox module.
- [Ui/Combobox/Multi](https://foldkit.dev/api-reference/ui-combobox-multi): API documentation for the Ui/Combobox/Multi module.
- [Ui/DatePicker](https://foldkit.dev/api-reference/ui-date-picker): API documentation for the Ui/DatePicker module.
- [Ui/Dialog](https://foldkit.dev/api-reference/ui-dialog): API documentation for the Ui/Dialog module.
- [Ui/Disclosure](https://foldkit.dev/api-reference/ui-disclosure): API documentation for the Ui/Disclosure module.
- [Ui/DragAndDrop](https://foldkit.dev/api-reference/ui-drag-and-drop): API documentation for the Ui/DragAndDrop module.
- [Ui/Fieldset](https://foldkit.dev/api-reference/ui-fieldset): API documentation for the Ui/Fieldset module.
- [Ui/FileDrop](https://foldkit.dev/api-reference/ui-file-drop): API documentation for the Ui/FileDrop module.
- [Ui/HoverIntent](https://foldkit.dev/api-reference/ui-hover-intent): API documentation for the Ui/HoverIntent module.
- [Ui/Input](https://foldkit.dev/api-reference/ui-input): API documentation for the Ui/Input module.
- [Ui/Listbox](https://foldkit.dev/api-reference/ui-listbox): API documentation for the Ui/Listbox module.
- [Ui/Listbox/Multi](https://foldkit.dev/api-reference/ui-listbox-multi): API documentation for the Ui/Listbox/Multi module.
- [Ui/Menu](https://foldkit.dev/api-reference/ui-menu): API documentation for the Ui/Menu module.
- [Ui/Nav](https://foldkit.dev/api-reference/ui-nav): API documentation for the Ui/Nav module.
- [Ui/Popover](https://foldkit.dev/api-reference/ui-popover): API documentation for the Ui/Popover module.
- [Ui/RadioGroup](https://foldkit.dev/api-reference/ui-radio-group): API documentation for the Ui/RadioGroup module.
- [Ui/Select](https://foldkit.dev/api-reference/ui-select): API documentation for the Ui/Select module.
- [Ui/Slider](https://foldkit.dev/api-reference/ui-slider): API documentation for the Ui/Slider module.
- [Ui/Switch](https://foldkit.dev/api-reference/ui-switch): API documentation for the Ui/Switch module.
- [Ui/Tabs](https://foldkit.dev/api-reference/ui-tabs): API documentation for the Ui/Tabs module.
- [Ui/Textarea](https://foldkit.dev/api-reference/ui-textarea): API documentation for the Ui/Textarea module.
- [Ui/Toast](https://foldkit.dev/api-reference/ui-toast): API documentation for the Ui/Toast module.
- [Ui/Toast/test](https://foldkit.dev/api-reference/ui-toast-test): API documentation for the Ui/Toast/test module.
- [Ui/Tooltip](https://foldkit.dev/api-reference/ui-tooltip): API documentation for the Ui/Tooltip module.
- [Ui/VirtualList](https://foldkit.dev/api-reference/ui-virtual-list): API documentation for the Ui/VirtualList module.
- [Update](https://foldkit.dev/api-reference/update): API documentation for the Update module.
- [Url](https://foldkit.dev/api-reference/url): API documentation for the Url module.

## Blog

- [Blog](https://foldkit.dev/blog): Announcements, musings, and technical deep dives.
- [Dispatch 1](https://foldkit.dev/blog/dispatch-1): APS-4 is on the fritz again.
- [Foldkit 0.154.0 and 0.155.0](https://foldkit.dev/blog/foldkit-0-155-0): Foldkit 0.154.0 and 0.155.0 expand click and focus controls, unify Vite builds for server-rendered apps, introduce HoverIntent, and more.
- [Foldkit 0.156.0 and 0.157.0](https://foldkit.dev/blog/foldkit-0-157-0): Two new recommended @foldkit/oxlint-plugin rules, less boilerplate when matching refined unions, plus updates to Story, Scene, Mount, @foldkit/ui, and Foldkit's Vite plugin.
- [Foldkit 0.158.0](https://foldkit.dev/blog/foldkit-0-158-0): Machine gains shared transitions, read-only context, simpler update integration, and a guide to defining, testing, and analyzing your application's workflows.
- [Foldkit Has Server Rendering](https://foldkit.dev/blog/foldkit-has-server-rendering): Your Foldkit application can now render to HTML at build time or per request, then hydrate on the client.
- [Foldkit Has a Blog Now](https://foldkit.dev/blog/introducing-the-foldkit-blog): The Foldkit blog now exists.

## Site

- [About Foldkit](https://foldkit.dev/about): What Foldkit is, who builds it, how changes are developed and released, and where the project stands before 1.0.
- [Contact Foldkit](https://foldkit.dev/contact): How to reach the Foldkit project: issues, Discord, security reports, and contributions.
- [Foldkit Privacy Policy](https://foldkit.dev/privacy): What foldkit.dev collects, what stays in your browser, the third parties involved, and the choices you have.