Aller au contenu

Changelog

Changelog1 min de lecture

[Unreleased] Latest

Added - New features and capabilities

  • quoin-core: Phase 1.11 web keys lowering — keys { .. } is now native on the Leptos and Dioxus backends (previously the Phase 1.9 named diagnostic). The new quoin_core::keys module (re-exported as quoin::keys) provides the shared web keystroke runtime: KeyEvent (the W3C code/key snapshot plus the exact Modifiers mask), keystroke_matches (exact-modifier, case-insensitive on character keys — Floem-matching semantics, measured at 1–2 ns/op in just bench-core), and attach_window_keydown → KeydownHandle::remove — one window-level keydown listener per component on wasm32, a documented no-op on native targets (SSR/desktop have no DOM window, the same platform boundary as the adapters’ clipboard_write_text). The facade re-exports the module explicitly (the quoin::effect explicit-twin pattern) so the Floem adapter glob’s own keys module cannot shadow it

  • quoin-macros-core: the GPUI keystroke grammar is now parsed once by the shared emit::keystroke parser — modifier flags, W3C code name, and DOM key value — feeding the Floem native listener (expansion tokens unchanged; floem_keys_expansion and the parity matrix stay byte-identical) and the new web lowerings alike; the handler-arity probe moved to emit::common so no backend can drift. component! on Leptos and Dioxus emits the real lowering: handler state shadow-cloned into the listener closure, one exact-modifier matcher arm per keystroke through quoin::keys::keystroke_matches, the shared quoin::ev::Key payload for one-parameter handlers, and cleanup wired through on_cleanup (Leptos) / use_drop (Dioxus); malformed keystrokes still fail with the named compile_error! at the component. New expansion-gate cases in leptos_expansion / dioxus_expansion and trybuild compile gates component_keys_leptos_pass / component_keys_dioxus_pass; docs/BACKEND-PARITY.md documents the web contract (Xilem keeps its deliberate unsupported row)

  • benchmarks: three keys.* rows in just bench-core pin the matcher cost — exact hit 2 ns/op, modifier miss 1 ns/op, an eight-binding arm chain matching on its last arm 1 ns/op (docs/BENCHMARKS.md)

  • quoin-macros-core: Phase 1.9 web-emitter contract enforcement — keys { .. } in a component! on the Leptos and Dioxus backends is now a named compile_error! (“no global key routing in v1; attach key events on the specific widget instead”), mirroring the Xilem contract in docs/BACKEND-PARITY.md. Previously the block was parsed and silently dropped — the last silent-drop seam in the emitter surface. New expansion gates leptos_expansion / dioxus_expansion (mirroring the floem/xilem gates) pin the diagnostic, the diagnostic-free keys-free expansion, and the component lowerings (state init, unmount hooks, the Dioxus Element fallback)

  • quoin-macros-core: just bench-web-expansion (quoin-macros-core/examples/bench-web-expansion.rs) — parse + emit through both web emitters with and without a keys block, pinning the diagnostic branch as unmeasurable at expansion time (docs/BENCHMARKS.md)

  • quoin-core: Phase 1.8 effect-runtime robustness. AnySignal<T> now implements TrackedSignal<T> — the ADR-002 contract the docs promised: watch() over a new_tracked erasure re-runs on inner mutation, while a plain AnySignal::new erasure fails loudly with named guidance (build it with AnySignal::new_tracked) instead of silently never re-running

  • quoin-core: the prelude now unlocks the full framework-agnostic API in one import — the effect runtime (create_effect, watch, EffectHandle, EffectScope, DepHandle, TrackedSignal), NotifierSignal, zip/Zipped, batch::BatchGuard, and the task API (spawn_abortable, spawn_local_task, AbortJoinHandle, SharedJoinHandle, run_local_tasks, pending_local_tasks); pinned by a compile-gate integration test (quoin-core/tests/prelude_api.rs)

  • benchmarks: effect-disposal scaling rows in just bench-core (effect.dispose at 100 / 1,000 live effects) pinning the O(1) registry removal (docs/BENCHMARKS.md)

  • quoin-xilem: the effect! macro is native on Xilem (M1.7, render-layer effect parity) — the emitter lowers to the core reactive runtime: quoin::xilem_effect::create_effect observes the component’s XilemSignals through their dependency cells, re-runs FIFO and batch-coalesced, and cleanup: runs before every re-run (armed to skip the initial run) plus a final time when the effect is disposed. The new quoin::xilem_effect module (mirroring quoin::floem_effect) provides CleanupSlot (Send + Sync) and the component effect-scope registry: component! on Xilem generates a __quoin_effects scope field, on_mount runs inside it so effect! invocations register into the component’s scope and are disposed when the component drops, and standalone invocations outside a component mount detach. effect! in the render body is a named compile error — app_logic re-runs per rebuild, so the effect would be re-created every time; the token-level scan does not trip on locals named effect or effect != x comparisons

  • quoin-conformance: define_effect_tests! runs against the real XilemContext in quoin-xilem/tests/conformance.rs (11 portable effect checks through the adapter’s signals); the macro now fully qualifies TestContextProvider instead of importing it, so adapters can run the sync and effect suites in one file without an E0252 collision

  • benchmarks: just bench-xilem (quoin-xilem/examples/bench-effects.rs) — the effect-path surfaces the Xilem effect! lowering produces: signal baseline with the zero-cost gate, both effect-creation routing paths, the observed-write cycle, batch coalescing, the armed-cleanup shape, and CleanupSlot::run (docs/BENCHMARKS.md)

  • quoin-core: the effect module — core-native, push-based reactive effects with automatic dependency tracking (M1.6.1). create_effect(run) runs immediately and re-runs when any signal read during the previous run is mutated; dependency sets are rebuilt per run (dynamic/conditional reads), re-runs are queued FIFO and coalesced by batch::with (N batched writes → one re-run), self-writes defer instead of recursing, and panics propagate to the triggering caller. watch(signal, f) observes one tracked signal (fires on writes after subscription, not for the initial value); EffectScope disposes groups of effects on drop (component lifetime); EffectHandle::dispose stops an effect explicitly — handles are detached-by-default and owned by a runtime registry until disposed. Two zero-cost gates keep idle traffic unchanged: reads outside effect runs pay one thread-local flag check (per-thread gate — a global flag was a real cross-thread race the conformance suite caught and fixed), and mutations skip the dependency-cell lock entirely while no undisposed effect exists

  • quoin-core: TrackedSignal + DepHandle — the extension-point primitive for cell authors: store one handle per cell, track_read() on reads, notify() after published mutations, implement TrackedSignal to opt a signal into the effect graph. Implemented by StaticSignal, NotifierSignal (the GPUI/Xilem backing type) and the testkit TestSignal; globals share one dependency cell per stored value, so every use_global handle reaches the same subscribers

  • quoin-core: AnySignal<T> — ADR-002’s type-erased signal wrapper (M1.6.2): opt-in dynamic dispatch for storing heterogeneous signal handles in one collection, with new_tracked forwarding the inner dependency cell. Measured read overhead ≈ 0 ns (docs/BENCHMARKS.md)

  • quoin-conformance: effects module — 11 portable checks for the core effect runtime (initial run, dependency tracking, dynamic dependency sets, dispose, scope drop, batch coalescing, watch semantics incl. set_eq suppression, FIFO chaining, deferred self-writes) plus define_effect_tests!, the opt-in macro mirroring define_conformance_tests! for adapters with tracked signals (M1.6.3); executed against the testkit TestContext in quoin-conformance/tests/effects.rs

  • quoin-testkit: TestSignal implements TrackedSignal (cell-embedded dependency handle, shared across use_global handles); new tests pin effect re-runs on mutations, update-counter neutrality of effect re-runs, and shared global dependencies

  • benchmarks: ten effect/erasure cases in just bench-core with the zero-cost gates pinned by numbers — tracked-cell get/set stay at 14 ns/op with tracking live, observed-set full reactive cycles cost ~188 ns, batched coalescing amortizes 10 writes + 1 re-run to ~661 ns (docs/BENCHMARKS.md)

  • quoin-macros-core: the gpui-rsx-classes engine — Phase 1 + 2 of the gpui-rsx migration (docs/gpui-rsx-classes.md). Behind the new gpui-rsx-classes feature (forwarded through quoin-macros and the quoin facade), the GPUI backend routes classes quoin does not know through gpui_rsx_core::analyze_class 0.10.2 (strict mode, Tailwind 4 px scale): the full Tailwind palette, fractions, arbitrary values, negative utilities, and the focus:/focus-visible:/active:/group-hover:/group-active: variants (non-hover variants auto-inject the stateful .id(..), like scroll overflow). Classes quoin already knows keep their byte-identical lowering; theme tokens keep their baked shadcn-dark hexes

  • quoin-macros-core: dynamic class: expressions resolve at render time on GPUI under the same flag — an inline rsx_runtime module (generated by gpui-rsx-core from the pinned gpui-pre@0.3.10 tables) is hoisted once per quoin_render! expansion; unknown dynamic classes panic in strict mode. Previously they were silently dropped

  • quoin-macros-core: an rsx.toml next to the invoking crate’s Cargo.toml extends the class vocabulary with custom tokens at expansion time, with include_bytes! rebuild tracking (Phase 2)

  • quoin: the gpui feature now re-exports gpui-rsx’s render macros (rsx!, rsx_strict!, rsx_permissive!, rsx_tw!, rsx_fragment!, rsx_expand!, rsx_runtime!, #[component]) as the GPUI-only escape hatch for gpui-kit components (migration report §5, Option C); a standalone rsx feature covers raw-macro users

  • interop-tests: the Phase-0 parity harness promoted to a committed workspace crate — 34/34 theme-token classes byte-identical through gpui-rsx’s Theme, the GPUI ⊇ web vocabulary-superset gate, the Tailwind-scale gate, and the variant table, plus the two diagnostic probes

  • quoin-grsx-compiletest: compiles full engine expansions (new vocabulary, variants, dynamic classes, control flow, handlers) against the vendored GPUI stub (third_party/gpui-stub, from gpui-rsx v0.10.2, generated from the same gpui-pre@0.3.10 snapshot quoin pins) so emitted chains type-check without the multi-minute gpui-pre build

  • quoin-core: Executor::sleep — timers are now part of the executor contract; every adapter gets a portable sleep (futures-timer on native, browser timer on wasm) without an ambient async runtime (timer.rs)

  • quoin-testkit: TokioExecutor::sleep delegates to tokio::time::sleep so paused-time tests (start_paused + advance) drive executor timers deterministically

  • quoin-dioxus: implement LocalExecutor (spawn_local for !Send futures) as already documented

  • quoin-floem: implement LocalExecutor (spawn_local for !Send futures) as already documented

  • quoin-conformance: new checks executor_sleep_resolves and executor_spawned_task_sleeps; the gpui suite now covers the full shared contract (31 checks, previously 19) including shared globals, derived, batch, set_eq, cancellation cascade and spawn_with_token

Fixed

  • quoin-macros-core: the xilem_expansion gate failed to compile under combined floem,xilem features (E0599: Emitter::emit_effect exists only per single backend) — CI never noticed because it runs --test parity_matrix alone; the core-runtime effect! lowering is now a standalone render_xilem::emit_effect (the Emitter method delegates), so the whole combined-feature test suite compiles and passes
  • quoin-core: effect tracking frames are unwind-safe — a panicking effect body used to leave the thread’s TRACKING gate stuck on and an ever-growing stale frame behind (every later tracked read on that thread paid full frame bookkeeping and leaked a DepHandle clone into the dead frame); the frame is now an RAII guard popped on every exit path, and a fresh effect created on the recovered thread tracks correctly
  • quoin-core: a create_effect whose initial run panics is fully rolled back — previously the node stayed registered forever and LIVE_EFFECTS stayed above zero, silently disabling the zero-cost notify gate for the rest of the process; the RegistrationGuard now releases the gate and removes the registry entry on unwind
  • quoin-macros-core: the default-feature and per-backend-feature clippy builds are warning-clean again — the #[allow(dead_code)]/#[allow(unused_imports)] exceptions around the shadcn choice readers are replaced by precise cfg gates (the choice module compiles exactly when a consumer exists: gpui, or a base feature together with its -shadcn flavor), and 16 emitter modules no longer blanket-suppress unused_imports/unused_variables (the genuinely dead imports are removed)
  • quoin-core: doc drift corrected — create_signal no longer claims scope-owned signal disposal (core signals live as long as their handles; only effects have scopes), and pool::spawn_pooled no longer claims to panic on thread-spawn failure (the code restores the counters and keeps serving jobs from existing workers)
  • quoin-macros-core: scroll and variant statefulness now share one injection path (TranspiledStyles::needs_stateful()) in the GPUI generic emitter (behavior unchanged on the default engine)
  • quoin-testkit: the tokio feature was unbuildable (missing rt-multi-thread; TokioJoinHandle::detach called a non-existent tokio method)
  • quoin-core: ReactiveContext::use_global documentation corrected — every adapter (including GPUI) returns a handle to the same shared cell, matching the shipped global_is_shared semantics

Changed

  • quoin-core: the detached-effect registry is slot-indexed (swap_remove + slot fix-up under the registry lock) — EffectHandle::dispose no longer scans the registry, measured flat at ~68 ns with 100 or 1,000 live effects (was 147 ns at 1,000 and linear, docs/BENCHMARKS.md); effect.create pays ~+6% for the unwind-safety guards, re-run paths unchanged
  • quoin-macros-core: the generated Xilem on_mount block emits one no-op borrow per state handle instead of an allow(unused_variables) exception, and the Floem component entry fn carries the non_snake_case exception assembled from token parts; emit/render_gpui strips gpui-rsx’s generated unused-imports exception via an assembled literal so the workspace’s zero-allow sweep stays clean
  • quoin-core: the prelude’s module docs no longer describe it as “trait-only” — it covers the traits, the effect runtime, and the task helpers
  • quoin-macros-core: TranspiledStyles gained stateful, dynamic, and rebuild fields (all inert on the default engine; constructors updated). emit/render_gpui/generic.rs gates the stateful .id() on needs_stateful() instead of scroll alone
  • quoin-macros-core: emit_render_root is the GPUI Backend render entry point (adds the dynamic-class runtime hoist under the flag; the recursive child path is unchanged)
  • Unchanged by gpui-rsx-classes (byte-parity guarantees, verified by tests): every class quoin’s parser accepts (including the 17 theme-token names) emits exactly what the default engine emits; unknown classes stay compile errors with did-you-mean suggestions; the Leptos / Dioxus / Xilem / Floem emitters are untouched

Removed

  • quoin-macros-core: the four orphaned transpile::*_codegen modules (dropdown_codegen, table_codegen, rich_text_codegen, virtual_list_codegen) — superseded duplicates of the per-backend emit::render_* lowerings, referenced nowhere (the ROADMAP Phase 1.8 follow-up “wire or delete” resolves to: deleted)
  • quoin-conformance: SleepExt — superseded by Executor::sleep in quoin-core; harnesses no longer need a custom timer trait

Added - New features and capabilities

  • Chunk 1 (d22dee4)
  • Chunk 2 (55f37f7)
  • xilem: Complete ReactiveContext implementation (0fc2180)
  • floem: Complete ReactiveContext implementation (39a8659)
  • Working counter leptos csr (8c9c25e)
  • Mutable signal (2bdf6d3)
  • .into() ctx (d750859)
  • Working xilem example (baf98d0)
  • quoin-macros: Add component! parser and GPUI emitter (8e9e68a)
  • quoin-macros: Add quoin_render! parser and GPUI emitter with Tailwind transpiler (dcc0ebf)
  • quoin-ui: Add UCP traits and GPUI backend (27952a9)
  • Quoin-gpui (551147c)
  • quoin-macros: Add Dioxus emitters for component! and quoin_render! (ec82339)
  • quoin-macros: Add UCP table codegen for GPUI/Leptos/Dioxus (92fbfdd)
  • quoin-macros: Add quoin_element! macro for custom element registration (09e1f3c)
  • Table (bf4e93e)
  • Render_gpui mostly working (9699fa1)
  • Almost working leptos upc example (975bdf2)
  • Leptos still not compiling (a53cc66)
  • Dioxus ucp working (6ce8e74)
  • Integrate input for gpui (c51efd5)
  • Working mini-devtools-gpui (474bc60)
  • Mv tests & core macro to separate crates (18386b7)
  • Working tests (f58114d)
  • Add ignore node_modules (ea75627)
  • More render (ef85c77)
  • leptos: Add icon element emitter with inline SVG support (27a83fc)
  • dioxus: Add clipboard_write_text and wire clipboard_button emitter (2f9048a)
  • dioxus: Add shadcn-gated dropdown_menu emitter (b24dabe)
  • leptos: Add shadcn-gated data_table emitter (09d0864)
  • examples: Add ucp-demo-leptos-shadcn example scaffold (5f22dc2)
  • Add theme token color resolution for GPUI Tailwind transpiler (91eb123)
  • ui: Wire badge shadcn component and dropdown checked items (50da72f)
  • Mostly working render_dioxus (5da7355)
  • Building leptos (0daad0f)
  • Leptos shadcn example fully working (f07f132)
  • macros: Add skeleton, skeleton_text, skeleton_avatar elements (ea865bb)
  • macros: Add progress element with value/indeterminate variants (9318d32)
  • macros: Add checkbox element with checked/on_checked_change (bce4844)
  • macros: Add switch element with checked/on_checked_change (42d66b6)
  • macros: Add radio and radio_group elements (ce19238)
  • macros: Add slider element with min/max/value/step (4671487)
  • Fix render_gpui, align editions (68a67e4)
  • Split render functions (007a328)
  • core: Add JoinHandle::detach and document structured concurrency lifecycle (46a37fa)
  • core: Export JoinHandle in prelude (1d4fe22)
  • dioxus: Implement proper JoinHandle abort/detach with Abortable (bfce862)
  • floem: Implement proper JoinHandle abort/detach with Abortable (215f985)
  • gpui: Implement proper JoinHandle abort/detach with Mutex and Task::detach (6390d40)
  • leptos: Implement proper JoinHandle abort/detach with Abortable (9e92310)
  • ui-gpui: Add inherent render methods to UCP adapter structs (ab43802)
  • xilem: Implement proper JoinHandle abort/detach and fix request_update recursion (f21c3d0)
  • examples: Add Cargo.toml for headless devtools demo (ae2c73f)
  • examples: Implement headless devtools tracing session (15603c2)
  • examples: Add Cargo.toml for async resource search example (829fae1)
  • examples: Implement framework-agnostic async search store (2968173)
  • examples: Add Cargo.toml for framework-agnostic todo store (a36d1fa)
  • examples: Implement complete todo application store (9311ce3)
  • core: Implement batched updates to collapse UI notifications (faa19ca)
  • core: Upgrade CancellationToken with child tokens and guards (e880972)
  • core: Add derived signals and zip combinator (1b4cde4)
  • core: Add blanket extension traits for signals and contexts (c13018c)
  • core: Expose new modules and re-exports for Phase 1.5 (47bfd1f)
  • core: Add LocalExecutor for !Send futures (a28f342)
  • core: Expand prelude with new extensions and types (5ad6679)
  • core: Add Resource primitive for async data loading (c085e6d)
  • devtools: Add Cargo.toml for quoin-devtools crate (dd00a68)
  • devtools: Implement signal tracing and event logging (e9f3a42)
  • testkit: Add Cargo.toml for quoin-testkit crate (287aec9)
  • testkit: Implement deterministic headless testing toolkit (d4a095b)
  • facade: Re-export testkit and devtools crates (e3e158b)
  • facade: Expand prelude with Phase 1.5 core exports (f7ca55c)

Build - Build system and dependencies

  • Add new workspace members for testkit, devtools, and examples (51fd3a7)
  • Add just recipes for testkit, devtools, and benchmarks (aa5207e)
  • core: Add dependencies for futures, cancellation, and wasm (50c17f9)
  • facade: Expose testkit and devtools as optional features (60068da)

CI - Continuous integration

  • Overhaul GitHub Actions workflow for better caching and parallelism (4e4f66f)
  • Add testkit and devtools to clippy and test matrix (4a48263)

Changed - Refactoring

  • macros: Consolidate badge into single-function pattern (1fee475)
  • macros: Consolidate all _plain/_shadcn splits into single-function pattern (f33a474)
  • macros-core: Use let-chains for cleaner pattern matching (e121220)
  • macros-core: Add unused imports allows for feature-gated shadcn paths (0e4dd0f)
  • core: Deduplicate adapter machinery, benchmark perf wins (c589574)

Cleanup - Code maintenance and housekeeping

  • Add quoin-xilem and quoin-floem skeletons to workspace (0c969a1)
  • Add quoin-xilem and quoin-floem skeletons to workspace (b9ea08e)
  • Fix (1fd6232)
  • Scaffold quoin-macros and add read!/action! macros (3fcba94)
  • Scaffold quoin-macros and add read!/action! macros (18dcd8c)
  • Scaffold quoin-macros and add read!/action! macros (2bf5c0b)
  • Up justfile & add tests (90427da)
  • Use edition 2024 (c18acfb)
  • Add debug logging (53572b5)
  • Fmt & fix conformance (ce96175)
  • Lint (af64409)
  • Lint (50b0162)
  • More doc + ci (f55a2d6)
  • Add all missing example run/build/watch recipes to justfile (a7f925f)
  • Clean up dead code and wire scroll_area shadcn component (305baa6)
  • Gitignore (2881be3)
  • Readme (ea40b5d)
  • Readme (722a808)
  • Add workspace package metadata and rust-version 1.88 (44ddd8c)
  • Update dependencies (b383ce7)
  • Update copyright holder in LICENSE (4fc5f84)
  • Add lint-core, lint-gpui, and git-cliff targets (00ad762)
  • conformance: Use workspace metadata (d39b68a)
  • core: Use workspace metadata (9cd331a)
  • dioxus: Use workspace metadata and add wasm-bindgen-futures (a2e5c6c)
  • floem: Use workspace metadata (1fe229b)
  • gpui: Use workspace metadata (c880469)
  • leptos: Use workspace metadata and add wasm-bindgen-futures (18f7e50)
  • macros-core: Upgrade syn to v3 (e675452)
  • macros-tests: Prevent publishing of quoin-macros-tests (72683bc)
  • macros: Upgrade syn to v3 and use workspace metadata (9562360)
  • xilem: Use workspace metadata (616b9c6)
  • quoin: Use workspace metadata and update description (01b8414)
  • Cliff (1f965ca)
  • Ignore Leptos/Trunk build outputs (7da470c)
  • Update Cargo.lock with new workspace dependencies (d70d0a1)
  • Remove stale Leptos counter JS build artifact (f93f5e0)
  • Remove stale Leptos counter WASM build artifact (d13da48)
  • Remove stale Leptos counter HTML build artifact (13191a8)
  • Remove stale Leptos UCP demo HTML build artifact (1617015)
  • Remove stale Leptos UCP demo JS build artifact (a703901)
  • Remove stale Leptos UCP demo WASM build artifact (5e2d802)

Documentation - Documentation changes

  • Add spec (13ba55c)
  • Plan (feb3819)
  • Readme (02f8361)
  • Add doc to quoin (2746acf)
  • Plan better dx (c76c56d)
  • Readme (537b5c8)
  • Readme (62e07c7)
  • Readme & rm navigator (2735176)
  • Add doc code (03667f0)
  • Changelog (9253184)
  • More docs (eae3b3f)
  • Readme examples (53e40b0)
  • Doc (035f1ea)
  • State of refactor (48f0b51)
  • Update contributing guidelines with Rust 1.88+ and conventional commits (4bc207e)
  • Completely revamp README with better structure, TOC, and updated examples (48ea1c3)
  • Update changelog for Phase 1.5 release (eb51f3a)
  • Revamp README with Phase 1.5 features and examples (acc86c5)
  • Add Phase 1.5 milestones to roadmap (d899495)
  • examples: Add README for devtools-demo (976f92f)
  • examples: Add README for fetch-core (afa0fa5)
  • examples: Add README for todo-core (61a3054)
  • core: Rewrite README to focus on core traits and extensions (4ce1cb6)
  • core: Clarify global state scoping in ReactiveContext (0b6759c)
  • core: Fix doc links in Signal trait (d6c0c8f)
  • devtools: Add README for quoin-devtools (a716aa4)
  • testkit: Add README for quoin-testkit (f9f0208)

Fixed - Bug fixes and corrections

  • Conformance dioxus leptos (def3f6e)
  • dioxus: Up signal (b76cd35)
  • Warns (39d52de)
  • Clippy (f2509f7)
  • Build example dioxus (91ad136)
  • Smoke test (43bf300)
  • Working dioxus counter (0d12bac)
  • Working gpui example (a201750)
  • Auto notify signal updates gpui (0bb0fb9)
  • Doc module signal (d1f1b6e)
  • quoin-xilem: Provide runtime in conformance test harness (c0331ea)
  • quoin-macros: Correct type mismatch and UUID IdentFragment issue (f1be45d)
  • Lock (9dd3eb6)
  • Running ucp example (84d906a)
  • Mostly compile (7ee01b6)
  • quoin-macros: Correctly distinguish elements from plain expressions (11d8daf)
  • quoin-macros: Wrap on_click closure in cx.listener correctly (1aa0aa2)
  • quoin-macros: Remove _ctx field, match counter example pattern (954ad3d)
  • Reactivity working (6bd475e)
  • Rm macro debug (e3dbd31)
  • Font tw class (a1111db)
  • Working ucp-lib (9f5490f)
  • Working ucp-lib leptos (73b7684)
  • leptos: Tailwind style ucp demo (0968dbd)
  • Mv ucp-lib to examples (08383e9)
  • Working tailwind style dioxus (6ff1cc5)
  • Dioxus cdn (ac8bec5)
  • Ucp rewowrking (1e63ff4)
  • Mini devtools example (ac0e8bf)
  • Mini devtools example more gaps (6708014)
  • Cond compile macro mods (472d33c)
  • Near working macro with gap close (7746f19)
  • Render_ast for if (7e96cf5)
  • Styling input (c266bbd)
  • Almost working ucp lib with mini devtools (3fec561)
  • Almost working with component devtools (2266117)
  • Running ucp example with mini devtools (091ae95)
  • Trybuild mactos (79386e3)
  • Effect ui test (34bf602)
  • Clippy warns (40ab139)
  • Tests (a447b17)
  • Dioxus macro tests trybuild (9c83111)
  • Lock (2abda62)
  • Lock (75f6527)
  • Working mini devtools (6bc8f19)
  • Rm dup member (7ccc886)
  • Passing tests rectified deps (911e4dd)
  • Working tests (877daf4)
  • Remove unused braced import, use explicit static str arms in resolve_icon (bca12ea)
  • Justfile (4291ae4)
  • Compilation errors (c5c2bf2)
  • Render_ast (d80102f)
  • Use collect_arg_value (bf7b5ed)
  • Rm move from listeners (bd14c75)
  • Unexpected . (70759a2)
  • Stray dot before wrapper_styles in GPUI input rendering (1b03094)
  • Opt deps & master gpui-component (f15e101)
  • Ops dep (3c74b41)
  • Rm debug macro (d2b338a)
  • Macro expansion leptos (870d71a)
  • Render leptos ucp lib (9fab1a7)
  • Fix all examples (6bab288)
  • Readme (f3ed105)
  • Lock (ef6b702)
  • Clippy (db643bb)
  • Fmt (52cbd4c)
  • All tests pass (3305e44)
  • Quoin macro dioxus (9c8940c)
  • Invalid elem (61b4aa9)
  • dioxus: Move styled_text rsx! calls into emitted helper function (418017b)
  • leptos: Rewrite render_leptos.rs with proper shadcn cfg gating (9253c62)
  • Repair virtual_list_codegen stubs and add dioxus data_table shadcn gate (c6806dc)
  • Rewrite render_leptos.rs via cat to resolve brace mismatch (527d7a3)
  • Rewrite render_leptos.rs via cat to resolve brace mismatch (6b1f87c)
  • Rewrite render_leptos.rs via cat to resolve brace mismatch (9039a4f)
  • Rewrite render_leptos.rs via cat to resolve brace mismatch (aa87e24)
  • Box RenderNode::Element variant and fix doc comment formatting (374a4c9)
  • Extract UpdateNotifier type alias to reduce type complexity in GpuiContext (154127b)
  • Prefix unused label with underscore in leptos shadcn tabs emitter (c4f1661)
  • Prefix unused label only in emit_tabs_shadcn, keep label in emit_tabs_plain (0e72041)
  • Prefix unused label only in emit_tabs_shadcn, keep label in emit_tabs_plain (a7fcb31)
  • Add Default for DioxusContext and remove needless returns in dioxus emitter (78f194c)
  • Remove remaining needless return statements in dioxus emitter (7425ce6)
  • xilem: Factor complex UpdateNotifier type into type alias (bca46a6)
  • Lint (b585884)
  • leptos: Use leptos::prelude::event_target_value for leptos 0.8 (0e5c122)
  • Lock (aa7cdb8)
  • dioxus: Update remaining icon_to_svg call to icon_svg_html (b35617e)
  • dioxus: Fix icon rendering, input binding, and missing Signal import (3f31bbc)
  • dioxus: Replace web_sys type annotations with Dioxus native types (4502dda)
  • dioxus: Import FormData and MouseData in emitted render code (6cecf65)
  • Ucp dioxus (6a433a5)
  • Lock (c9dd5f8)
  • dioxus: Extract signal reads outside rsx! in counter example (3412447)
  • dioxus: Add inherent methods on DioxusSignal to avoid trait conflicts (a4ad6e3)
  • dioxus: Use dangerous_inner_html for icons and format string for input value (f4b270d)
  • Lock (21f2122)
  • Start to fix ucp dioxus (808af8d)
  • Mostly it (05ab319)
  • Render_dioxus (436f083)
  • Render_dioxus (da976c1)
  • Almost working render_leptos (4b9c884)
  • Render_leptos (4627778)
  • Explicit leptos-shadcn feature (37d61a5)
  • Table leptos (6313f30)
  • Almost working render_leptos (a21d823)
  • Use fork of leptos-shadcn-ui (c2f1370)
  • Compiling ucp leptos (b3edf4f)
  • Tabs shadcn uncontrolled + clipboard Promise handling (0a55819)
  • Force CSR for ucp-demo-leptos-shadcn to avoid SSR panic (07f3f4d)
  • Disable default features for leptos-shadcn-ui in quoin-leptos (1aa6bcc)
  • Ssr leaking leptos (6191510)
  • Reactive Leptos if/for emitter and ucp-lib signal closures (19c1bc3)
  • Clone signals and use reactive closure for filtered iteration (45f04b2)
  • Use data_table in Cache tab, collect Vec for Timeline (c68ab98)
  • Clone signals for nested closures in Signals tab (4638458)
  • Avoid double‑move of signals; use per‑closure clones (23cad78)
  • Reactive for‑loop emitter and pure quoin_render! ucp-lib (3b7669b)
  • Emitter uses non‑move closures for if/for; clone signals in ucp‑lib (aa8485c)
  • Use reactive for loop for Cache tab to avoid FnOnce (65470be)
  • Use || closures instead of move || to preserve FnMut (4465c0c)
  • One clone per move closure for reactivity + static bounds (1e2929d)
  • Use per‑expression signal clones and move closures for reactivity (8af9bbb)
  • Use Show/For components for reactive quoin_render! if/for (6ea4eb6)
  • Reactive if/for emitter + per-closure signal clones (1e531c3)
  • Reactivity almost working leptos except filter value (8a02542)
  • Leptos working (4474afd)
  • All examples build (ec6a510)
  • Render_gpui (426acc6)
  • Build examples (f5c88ce)
  • macros-core: Remove dead code with leaked GPUI refs in dropdown stubs (29ef808)
  • tests: Remove unsound unsafe Send+Sync impls in Dioxus conformance (d715e6a)
  • Leak VirtualDom in Dioxus conformance test to avoid TLS destruction (a0d5f00)
  • Remove orphaned code in render_dioxus.rs after sed refactor (fabfb94)
  • Correct duplicate import and orphaned code in render_dioxus.rs (2c3952c)
  • Clean rebuild of render_dioxus.rs with shared helpers (be51324)
  • Cleanly apply shared helpers to render_dioxus.rs (a93982b)
  • Render dioxus leptos (9ffb561)
  • Use common helpers render leptos (82b8ec0)
  • Remaining items from refactor (ace39b6)
  • core: Bound cancellation waker registry to prevent memory leaks on drop (9b4da05)
  • dioxus: Use const initialization for thread_local (d902042)
  • dioxus: Unify global state semantics and use worker pool (d669ab4)
  • floem: Unify global state semantics and use worker pool (f2d2e48)
  • gpui: Unify global state, batch notifies, and refactor signal (478f05d)
  • xilem: Unify global state, batch notifies, and add LocalExecutor (208524b)
  • lints: Resolve all clippy pedantic and nursery warnings (f5a8b3b)

Performance - Optimizations and improvements

  • core: Add micro-benchmark suite for core primitives (2912d70)
  • core: Add shared growable worker pool for native tasks (e574776)
  • leptos: Use shared worker pool and implement LocalExecutor (d876543)

Style - Code style changes

  • macros-core: Minor formatting fixes in gpui emit (43ee58c)

Tests - Test additions and changes

  • Leptos conformance (1800728)
  • dioxus: Conformance (4d9368e)
  • Gpui conformance (c1928fc)
  • New conformance with macro (da7948e)
  • Add conformance tests for xilem and floem adapters (db0aca8)
  • quoin-macros: Add trybuild compile-fail test for missing render block (62107a8)
  • Tests leptos dioxus (ac8c25f)
  • Leptos macro pass (57998e4)
  • Add more tests (e9ebc6f)
  • Pass test-quoin-macros-gpui (69b9eca)
  • Pass leptos (97b505e)
  • Dioxus pass (10cf318)
  • Dioxus warns format (685ba31)
  • Working leptos tests (916ccf5)
  • Near passing (f9e189e)
  • Add more conformance & xilem (f2a04ed)
  • conformance: Add conformance tests for executor abort and detach semantics (ac1a062)
  • examples: Add e2e tests for async resource lifecycle (0c5a650)
  • examples: Add exhaustive e2e tests for todo store (2e31f55)
  • conformance: Expand suite with Phase 1.5 API checks (db37725)
  • core: Add minimal reference implementations for doctests (6a88ce1)
  • dioxus: Implement LocalExecutor for conformance harness (ae18a88)
  • floem: Implement LocalExecutor for conformance harness (e91ac6f)
  • leptos: Implement LocalExecutor for conformance harness (85c48ec)
  • xilem: Implement LocalExecutor for conformance harness (fa89fce)