feat(vapor): compile Solid and Vue TypeScript views and models to Rust

[HalfSweet]

Summary

Compile Solid TSX and Vue SFC views, plus an admitted TypeScript model, into a native Rust application. With app.aot: true and app.model: "compiled", state seeds, methods, memos, effects and tasks are generated from the TypeScript implementation. The default "rust" mode retains an application-provided Rust model implementing the same generated trait.

The supported application source language is TypeScript. JavaScript is an emitted format for browser and QuickJS execution, not an additional source-language support promise. The compiled model's guest build uses the framework reaction scheduler and task state machines; its native build executes generated Rust without a guest engine.

• Share typed View IR format 4 between Solid and Vue, while Model IR format 1 records model bodies, dependencies, schedules and coroutine states. The view generator consumes the typed contract without loading model bodies.
• Support component props and events, mount-owned factory state and arguments, keyed rows, lifecycle rounds, scoped slots, concrete generic specializations, root context, node refs and hardware-neutral relative-axis input.
• Preserve frame-atomic dispatch, on-demand memo reads, settled render caches, owned-value semantics, fixed-width arithmetic and bounded strings/arrays. Reject unsupported models with source-located diagnostics; there is no fallback to another implementation.
• Lower async model functions into region-owned tasks with restart/cancellation, boundary readiness, frames/after/until, joins, aggregate waits, typed network requests and animation completion. Cancelling an animation wait drops its listener while preserving the issued motion.
• Integrate compiled models into the Solid lab, build plans, browser/guest transforms and native host protocol. Both transform passes and model resolution follow the selected presentation entry. Demo gen/ files are ignored and generated before native builds and resource tests.
• Add hand-authored semantic fixtures, negative cases, interpreter/TypeScript/Rust differential checks, full-view and lifecycle regressions, allocation checks and local fuzz tooling. CI runs the fixed semantic suite; fuzz campaigns and generated seed variants remain local.
• Check generated output through focused type/structure assertions and native compilation instead of storing complete demo Rust or IR snapshots. Preserve hand-written behavior expectations and minimized regression inputs; core Model IR is regenerated from TypeScript during tests.

TypeScript and native responsibilities

Boundary	Contract
Source admission	.ts model implementations, .tsx views and typed Vue scripts follow their documented subsets. Arbitrary packages, native promises, timers and dynamic model constructs are not implied by TypeScript support.
Model implementation	"compiled" generates the native implementation; "rust" requires handwritten Rust. A .d.ts guest preview supplies defaults and empty methods, not Rust behavior.
View to model	Generated Rust calls a Rust trait. The guest and native model are separate instances; they do not share state or exchange TypeScript objects through FFI.
Model to host	Ready freezes frame/time/capabilities/deliveries; Cmd carries issued work. Native async entries take a command sink and return (), with source results delivered to awaiting model tasks.
Services and devices	A typed net.get declaration does not implement native networking. A host must advertise the service, handle requests/cancellations and queue results. The default Ui declares no services. Physical input and presentation remain host responsibilities.
Memory and numbers	Rust AOT uses no_std with alloc. Cap bounds specified storage, not every allocation. Guest 64-bit integer precision remains limited; the zero-allocation claims below apply to selected bounded fixtures.
Targets	Board admission checks declared input channels; it does not provide a port or toolchain. The earlier C cartridge compiler lives in the standalone pocket-stack/pocket-vapor repository; its sources and scripts are not restored here.

Documentation

The TypeScript and native code guide covers execution selection, generated code ownership, the Rust trait boundary, service submission and delivery, cancellation, resource limits and packaging. It includes a TypeScript network example checked against all three execution paths.

The model guide, Solid/Vue guides, shared reference, architecture, native contract, build pipeline and README now describe the compiled and handwritten model modes and distinguish TypeScript source support from engine output.

Validation

Validated rebased source: bcff0421276d08cddaf773e86597c261ba9e0a65; mainline base: 53a17f6416c3333f1171141bf996695720101ed2.
Desktop tools: Bun 1.3.14, Rust 1.93.0.

CI=true CARGO_NET_OFFLINE=true bun tools/test.ts --stage=AOT
CI=true CARGO_NET_OFFLINE=true bun test tests/platform-contracts.test.ts tests/modality.test.ts tests/host-build-inputs.test.ts tests/tape-assert.test.ts tests/test-suite.test.ts tests/font-config.test.ts tests/font-archive.test.ts tests/native-source.test.ts
CI=true CARGO_NET_OFFLINE=true bun test --conditions=browser tests/devtools.test.ts
CARGO_NET_OFFLINE=true cargo test --manifest-path engine/core/Cargo.toml
CARGO_NET_OFFLINE=true cargo test --manifest-path engine/Cargo.toml -p pocket_vapor --features model-trace
CARGO_NET_OFFLINE=true cargo test --manifest-path engine/ui-cabi/Cargo.toml
bun tests/contract.ts
git diff --check

The offline flags use the validation machine's populated Cargo cache; omit them to fetch dependencies on a fresh machine.

• 432 AOT tests passed: 146 frontend/execution checks and 286 model semantics/resource checks. These include both Solid and Vue selected-presentation regressions, native demo compilation, three-way behavior comparison and fixed minimized regressions. Fuzz is excluded under CI=true.
• 167 upstream integration and DevTools tests passed, preserving modality selection, manifest/build contracts, streamed-font integration, tape assertions and touch recording behavior.
• 180 Rust tests passed: core 155, model runtime 9 and UI C ABI 16; doc-tests passed.
• Compiler source type checking, integration type checking with strict null checks, generated-contract drift checks and whitespace checks passed.
• The Solid lab completed 2,048 frames under the 24 MiB allocation cap; measured peak 125,625 bytes. Bounded primitive/tagged reaction and task fixtures assert zero allocations after mount. Frame timings are recorded without a latency acceptance threshold.

The rebase preserves mainline's removal of the earlier cartridge compiler. Native AOT board checks use a separate input-only profile registry; no retired C compiler, toolchain or board runtime is restored. Demo build output and full-output snapshots remain untracked, and local-only fuzz tests have an explicit exclusion in the expanded test inventory.

Acceptance is exit status 0, exact trace/state/command agreement where asserted, and the stated allocation bounds. Logs and receipts remain under ignored .pocket-build/validation/model-aot/rebase-20260921/; no per-run artifacts are committed.

Prior ESP32 compile/link validation

This compile/link receipt was recorded before the rebase at f6a78cc08a1b3053adb13a34f5e3accb45d8691d. It has not been rerun against the rebased mainline core. The existing ESP-IDF AOT embedding project built the compiled Solid lab. After exporting the project's ESP-IDF and ESP Rust environments:

cd .pocket-build/validation/model-aot/esp32/project
CARGO_NET_OFFLINE=true idf.py -B ../build \
  -DAOT_APP=solid-aot-lab -DAOT_MEMORY_PROFILE=OFF build

• ESP-IDF: v5.5-dev-1998-gc71d74e2f8-dirty; ESP Rust: 1.97.0-nightly (8ea53bcd7 2026-07-08), LLVM 21.1.3.
• Firmware: 620,944 bytes in a 3,145,728-byte application partition; build exit status 0 and all 44 native input hashes matched the validated sources.
• Firmware SHA-256: 9b29944f66c3099058b06f9401eadb5b8542ee1677d97878e09f4da0a39e27f8.
• No flashing or device-run acceptance is claimed. This establishes compilation and linking, not device frame time, pixels or physical relative-axis input.