Overview - Query

queryWorkspace

CI Pipeline Executions
- Filtered
Runs
Demo

Insights

Compare tasks
Analytics

Overview

query

Loading workspace stats

Loading workspace insights...

Statistics interval

7 days30 days

Latest CI Pipeline Executions

Filter

Fuzzy

Sort by

© 2026 - Nx Cloud

Terms of Service Privacy Policy Changelog Status Docs Contact Nx Cloud Pricing Company @NxDevTools

queryWorkspace

Average execution time

3m 34s

640 CI pipeline executions

Computation time saved

4d 7h

Cache hit rate

31%

Time to Green

12m 57s

Was 16m 24s, improved by 21%

Succeeded
solid-query-v6-pre
cb63f070 fix(solid-query): follow Solid 2.0.0-rc.9 (#11543) Build with @solidjs/babel-plugin (the Solid 2.0 compiler; rc.9 moved delegated handlers to the `_$$` key, so the compiled output must match the runtime), test under vite 8 for the Solid packages, examples and the vite integration (scoped overrides; @solidjs/vite-plugin next.32+ needs vite ^8), and raise the solid-js / @solidjs/web peer floor to rc.9. useQuery: setup-time snapshots (meta projection seed, mount counts) read the cache through lookupQuery() instead of query(), which reads the version signal. Under hydration, priming writes that signal during setup and Solid holds a write made during the pass: a computation in the pass that reads it is served the pre-write value and replays at release. For the hook's derived nodes that is the takeover; for the computation instantiating the component (a <Loading> boundary's children) it was a remount that re-created the hydrated component as a client render, so cache writes reached the DOM while the stream was open. Tests: four assertions adapted to rc.9's committed-frame model (a write becomes visible at flush, to every channel): status/isPending read the held frame mid-hold, isFetching is the pending probe; the mutation settle commits fresh data and the lifted overlay in one frame. Co-authored-by: Claude Fable 5.1 <noreply@anthropic.com>
by Ryan Carniato
Succeeded
11543
24d8bfee fix(solid-query): follow Solid 2.0.0-rc.9 Build with @solidjs/babel-plugin (the Solid 2.0 compiler; rc.9 moved delegated handlers to the `_$$` key, so the compiled output must match the runtime), test under vite 8 for the Solid packages, examples and the vite integration (scoped overrides; @solidjs/vite-plugin next.32+ needs vite ^8), and raise the solid-js / @solidjs/web peer floor to rc.9. useQuery: setup-time snapshots (meta projection seed, mount counts) read the cache through lookupQuery() instead of query(), which reads the version signal. Under hydration, priming writes that signal during setup and Solid holds a write made during the pass: a computation in the pass that reads it is served the pre-write value and replays at release. For the hook's derived nodes that is the takeover; for the computation instantiating the component (a <Loading> boundary's children) it was a remount that re-created the hydrated component as a client render, so cache writes reached the DOM while the stream was open. Tests: four assertions adapted to rc.9's committed-frame model (a write becomes visible at flush, to every channel): status/isPending read the held frame mid-hold, isFetching is the pending probe; the mutation settle commits fresh data and the lifted overlay in one frame. Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
by Ryan Carniato
R
Succeeded
11469
194bc526 fix(solid-query): read undefined from a disabled query instead of suspending A read of a disabled query with nothing cached used to park on a promise that never settles. Nothing revives that promise — enabling the query or writing to the cache re-runs the compute and abandons it — so any consumer that waits on it rather than recomputing hangs: the SSR stream never completes (no interaction can enable the query), and a <Loading> boundary whose enabling control sits inside it replaces that control with the fallback. The read now returns `undefined` for that state, which is what React Query's `useQuery` returns for a disabled query. Enabling, a refetch or a cache write re-runs the compute and the read becomes a normal pending or settled read. Since the node already committed `undefined`, the first fetch after enabling holds the committed UI like any refetch; `isLoading` reports it, matching the `data: undefined, isLoading: true` shape. `data` widens to `TData | undefined` only for options that can disable the query (`enabled` that is not literally `true`, or a `queryFn` that may be `skipToken`) and have no `initialData`; a new `AlwaysEnabledOptions` overload keeps the suspending `TData` face for everything else. The same rule applies to `useInfiniteQuery`, `useQueries`, `queryOptions` and `infiniteQueryOptions`. A function `placeholderData` now receives the previous query's data for a disabled query, where the engine has no pending fetch to hold the previous value against, so `keepPreviousData` behaves as in React Query there. The hydration-window parks (adoption, priming, restore) are unchanged. Co-authored-by: Cursor <cursoragent@cursor.com>
by Ryan Carniato
R
Succeeded
solid-query-v6-pre
09f26661 fix(solid-query): sweep X-Revalidate without a slice; reserve '*' for all (#11517) The single-flight consumer assumed every delivery carried a dehydrated slice, so a response that declared revalidation keys but folded nothing for the query cache (no collector registered, a redirect leaving the app) threw on payload.queries. The sweep now treats a missing payload as covering nothing and sweeps the declared scope in full. The header's three states are three scopes: absent leaves the cache alone (a bare redirect()/reload() is a host default the query cache does not presume), an empty declaration (revalidate: []) sweeps nothing — an empty key is not a prefix that matches everything — and the reserved key '*' (revalidate: '*') invalidates every query the payload did not cover. Co-authored-by: Claude via Cursor <noreply@cursor.com> Co-authored-by: Cursor <cursoragent@cursor.com>
by Ryan Carniato
Succeeded
11517
3c354d7a fix(solid-query): sweep X-Revalidate without a slice; reserve '*' for all The single-flight consumer assumed every delivery carried a dehydrated slice, so a response that declared revalidation keys but folded nothing for the query cache (no collector registered, a redirect leaving the app) threw on payload.queries. The sweep now treats a missing payload as covering nothing and sweeps the declared scope in full. The header's three states are three scopes: absent leaves the cache alone (a bare redirect()/reload() is a host default the query cache does not presume), an empty declaration (revalidate: []) sweeps nothing — an empty key is not a prefix that matches everything — and the reserved key '*' (revalidate: '*') invalidates every query the payload did not cover. Co-authored-by: Claude via Cursor <noreply@cursor.com> Co-authored-by: Cursor <cursoragent@cursor.com>
by Ryan Carniato
R
Succeeded
solid-query-v6-pre
f41ac714 feat(solid-query): sweep X-Revalidate keys in the single-flight consumer (#11394) A mutation can declare its invalidation scope with X-Revalidate keys (Solid's reload/redirect `revalidate` option). The flight payload covers the part of that scope the server's collector recomputed — typically the target page's loader graph — but a declared key can match more than any loader knows about: parameterized instances only the client holds (['users', 2] behind a paginated list), queries no loader owns (a layout's notification count). Those previously stayed stale until their own staleTime brought them back. The provider's flight consumer now finishes the job client-side: after hydrating the payload, each declared key is invalidated by queryKey prefix — active queries refetch in the background, inactive ones are marked stale for their next mount — with payload-covered hashes exempt (they hydrated with fresh data a moment ago; refetching them would spend the round trip single flight just saved). This mirrors how Solid Router consumes the same header for its own cache, so one `revalidate` declaration on a mutation scopes both caches consistently. No wire or protocol changes: the keys already ride the response headers the consumer receives as envelope context. Collectors should contribute their slice even when it holds no queries if outcome.revalidateKeys is present — the sweep is delivered with the slice (documented on FLIGHT_DATA_SOURCE). Co-authored-by: Cursor <cursoragent@cursor.com>
by Ryan Carniato
Succeeded
11394
0687fdab feat(solid-query): sweep X-Revalidate keys in the single-flight consumer A mutation can declare its invalidation scope with X-Revalidate keys (Solid's reload/redirect `revalidate` option). The flight payload covers the part of that scope the server's collector recomputed — typically the target page's loader graph — but a declared key can match more than any loader knows about: parameterized instances only the client holds (['users', 2] behind a paginated list), queries no loader owns (a layout's notification count). Those previously stayed stale until their own staleTime brought them back. The provider's flight consumer now finishes the job client-side: after hydrating the payload, each declared key is invalidated by queryKey prefix — active queries refetch in the background, inactive ones are marked stale for their next mount — with payload-covered hashes exempt (they hydrated with fresh data a moment ago; refetching them would spend the round trip single flight just saved). This mirrors how Solid Router consumes the same header for its own cache, so one `revalidate` declaration on a mutation scopes both caches consistently. No wire or protocol changes: the keys already ride the response headers the consumer receives as envelope context. Collectors should contribute their slice even when it holds no queries if outcome.revalidateKeys is present — the sweep is delivered with the slice (documented on FLIGHT_DATA_SOURCE). Co-authored-by: Cursor <cursoragent@cursor.com>
by Ryan Carniato
Succeeded
solid-query-v6-pre
72f81855 feat(solid-query): built-in single-flight consumer via FLIGHT_DATA_SOURCE (#11326) * feat(solid-query): built-in single-flight consumer via FLIGHT_DATA_SOURCE Solid's single-flight channel is becoming multi-source (solidjs/solid 653dd41e): mutation responses carry a keyed envelope of per-cache slices, each routed to the consumer subscribed under its source id, so independent caches (Solid Router's route data, the query cache) refresh from one round trip without competing for the single legacy slot. QueryClientProvider now subscribes the query cache's consumer under the exported FLIGHT_DATA_SOURCE id ("sq", matching the sq: hydration-registry namespace): a mutation response carrying that slice — a DehydratedState produced by a server collector registered with registerFlightDataSource(FLIGHT_DATA_SOURCE, hook) — hydrates the provider's client before the mutation's promise resolves. Mounted queries on those keys update with no follow-up refetches, and apps delete the hand-rolled subscribeFlightData/hydrate wiring entirely. Subscribing is inert when no server collector exists (the server folds nothing), client-only (the server registry is cross-request module state), and torn down with the provider. Requires the @solidjs/web release following 2.0.0-rc.4 for the named-source protocol; a typed shim bridges the installed declarations until the peer range bumps. Co-authored-by: Cursor <cursoragent@cursor.com> * feat(solid-query): dehydrateSettled, SSR teardown, and dehydrate filtering Fills the gaps the router-ssr-query transport used to cover, natively: - dehydrateSettled(client): the extraction half of a single-flight collector — waits for every in-flight fetch (chased to quiescence) so loaders' fire-and-forget prefetches land before dehydrating. - SSR teardown: the provider cancels and clears the per-request cache on render disposal, so user-configured finite gcTime timers cannot pin the client after the response. - The registry serializer now respects defaultOptions.dehydrate .shouldDehydrateQuery, the same knob apps use on any other transport. Co-authored-by: Cursor <cursoragent@cursor.com> * chore(solid-query): require solid 2.0.0-rc.6, drop the subscribe type bridge rc.6 publishes the named flight-data source API with real types, so the subscribeFlightData cast goes away; the peer floor moves to rc.6 because rc.5's settle-walk regression breaks query hydration. Also adds the missing changeset for dehydrateSettled and the SSR teardown work. Co-authored-by: Cursor <cursoragent@cursor.com> --------- Co-authored-by: Cursor <cursoragent@cursor.com>
by Ryan Carniato
Succeeded
11326
5f2f3fe6 chore(solid-query): require solid 2.0.0-rc.6, drop the subscribe type bridge rc.6 publishes the named flight-data source API with real types, so the subscribeFlightData cast goes away; the peer floor moves to rc.6 because rc.5's settle-walk regression breaks query hydration. Also adds the missing changeset for dehydrateSettled and the SSR teardown work. Co-authored-by: Cursor <cursoragent@cursor.com>
by Ryan Carniato
Failed
11326
5f2f3fe6 chore(solid-query): require solid 2.0.0-rc.6, drop the subscribe type bridge rc.6 publishes the named flight-data source API with real types, so the subscribeFlightData cast goes away; the peer floor moves to rc.6 because rc.5's settle-walk regression breaks query hydration. Also adds the missing changeset for dehydrateSettled and the SSR teardown work. Co-authored-by: Cursor <cursoragent@cursor.com>
by Ryan Carniato
Succeeded
solid-query-v6-pre
209f9f51 fix(solid-query): scope useMutation's cache subscription to the flight (#11325) The hook subscribed to the mutation cache at mount with a bare reactive client() read — tripping Solid's STRICT_READ_UNTRACKED dev diagnostic (reported by @brenelz in #11324) — and held that subscription for its whole life even though the listener only matters between mutate and settle. Rather than untracking the read, remove it: subscribe inside run(), against the same client the mutation is built on, and unsubscribe at the settle points (plus onCleanup for unmount mid-flight). By construction: no reactive read at setup (nothing to untrack), the listener and the mutation can never sit on different clients across a QueryClient swap, and an idle useMutation holds no cache subscription — mutation-cache events no longer fan out to every mounted hook. Includes the #11324 regression test (no strict-read diagnostic on mount) plus a listener-count test pinning the idle/flight/settled subscription lifecycle. Co-authored-by: Cursor <cursoragent@cursor.com>
by Ryan Carniato
Succeeded
11325
afe2bf12 fix(solid-query): scope useMutation's cache subscription to the flight The hook subscribed to the mutation cache at mount with a bare reactive client() read — tripping Solid's STRICT_READ_UNTRACKED dev diagnostic (reported by @brenelz in #11324) — and held that subscription for its whole life even though the listener only matters between mutate and settle. Rather than untracking the read, remove it: subscribe inside run(), against the same client the mutation is built on, and unsubscribe at the settle points (plus onCleanup for unmount mid-flight). By construction: no reactive read at setup (nothing to untrack), the listener and the mutation can never sit on different clients across a QueryClient swap, and an idle useMutation holds no cache subscription — mutation-cache events no longer fan out to every mounted hook. Includes the #11324 regression test (no strict-read diagnostic on mount) plus a listener-count test pinning the idle/flight/settled subscription lifecycle. Co-authored-by: Cursor <cursoragent@cursor.com>
by Ryan Carniato
Succeeded
solid-query-v6-pre
c809e09e feat(solid-query): rewrite the adapter onto Solid 2.0's native async model (#11308) * feat(solid-query): rewrite the adapter onto Solid 2's native async model Reads become a single async memo over the query cache (suspends into <Loading>, holds previous data through refetches, routes rejections to <Errored>, serializes settled values for streaming hydration); mutations ride Solid core's `action` primitive with transactional settle and optimistic overlays; cross-cache hooks share a dual-write aggregate with a hydration latch. The observer notification/store layer (createStore/reconcile, tracking proxies, notifyManager batching) is deleted — QueryObserver/MutationObserver remain as lifecycle/policy engines with noop listeners. Breaking: result `data` is non-optional (reads suspend instead of returning undefined), mutateAsync is removed (mutate returns a promise), and the reconcile/suspense/deferStream options are removed. SSR contracts pinned by the fixture suite: settled-only serialization for every exposed field, hydration id parity, no fetches inside the hydration/restore windows, and hydration-latched cross-cache aggregates. Validated against solid-js 2.0.0-rc.0 and rc.3, including an end-to-end template run with single-flight mutations. Co-authored-by: Cursor <cursoragent@cursor.com> * ci: apply automated fixes * feat(solid-query): wire deferStream through to Solid's per-computation SSR option deferStream was declared in the option types on this line but wired to nothing. Solid 2 exposes it as a creation-time memo option, so pass it straight through to the data node: the server holds the stream flush until the query resolves instead of flushing the surrounding boundary's fallback. Server-only; ignored on the client. Co-authored-by: Cursor <cursoragent@cursor.com> * feat(solid-query): serve data through an auto-reconciling store projection Solid 2 projections auto-reconcile their returns by key, so the data face becomes a store: deep reads are fine-grained and item identity survives across refetches (keyed by the new `reconcile` option, default 'id'). The async memo remains the SSR/hydration spine underneath; the projection derive is inert on the server — server projections run eagerly at creation, so a live derive would fetch at hook creation and serialize a duplicate payload, and the serialized entry would latch the hydrating client's projection for the whole stream. With nothing serialized the client projection computes live through the hydration window. Rewrites the structural-sharing test to the stronger store contract and adds leaf-granularity, custom-key, and primitive-data semantics tests. Co-authored-by: Cursor <cursoragent@cursor.com> * fix(solid-query): green up CI for the native rewrite - align @solidjs/web, babel-preset-solid and solid-js dev ranges across the solid packages (sherif flagged the split, and devtools/persist-client were resolving a second solid-js copy) - drop the unused `export` on the internal BaseQueryLayer seam (knip) - port the PersistQueryClientProvider suite to the 2.0 read layer: a query with nothing cached now suspends for the whole restore window, so the tests assert the visible fallback -> restored -> refreshed transitions and the fetch/callback bookkeeping instead of observer result snapshots Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> * refactor(solid-query): unify the data node into a single hybrid projection Collapse the three-node data face (serialized async memo + transparent hydration memo + client-only projection) into one createProjection with an identical derive on both sides — the Solid Router feed-query-into- projection shape. The engine owns SSR serialization (deferStream rides the projection now), suspense, hydration adoption, and keyed reconciliation. ssrSource 'hybrid' keeps hydrated components live: the serialized value claims the DOM and the derive re-takes over from the live cache per hydrated region. A per-hook `primed` signal gates the pull-model fetch so the hydration takeover recompute cannot race data the channel is about to deliver (SSR-errored queries fall through and fetch normally once the channel declines them). Co-authored-by: Cursor <cursoragent@cursor.com> * refactor(solid-query): default ('server') hydration semantics for the data node Drop ssrSource 'hybrid' from the data projection: query data IS server-serialized truth, so the serialized value owns the DOM for the whole hydration window. Mid-stream cache writes commit when the stream closes through Solid's hydration-end divergence takeover (solid-js > 2.0.0-rc.3 — earlier engines lose a latched node's mid-stream divergence instead of deferring it). Network activity is unchanged: observers attach per-query as the channel primes, so mid-stream invalidations still refetch immediately; only the DOM commit defers to hydration end. Co-authored-by: Cursor <cursoragent@cursor.com> * refactor(solid-query): single-channel hydration — the node payload is the transport Delete the provider-owned dehydration channel and its coordinator. The data projection's serialized root now carries the cache facts hydration needs ({ value, t: dataUpdatedAt, raw?: pre-select data }); on a hydrated mount each hook peeks its projection's node id, loads that entry itself, primes the query cache through query-core hydrate() (staleness intact, newer-wins, silent under external pre-priming), and attaches its observer per query as chunks land. One serialization story, engine-owned; ~240 lines deleted. Requires solid-js > 2.0.0-rc.3 (peekNextChildId export). Co-authored-by: Cursor <cursoragent@cursor.com> * chore(solid-query): drop internal porting notes from the tree Co-authored-by: Cursor <cursoragent@cursor.com> * refactor(solid-query): content-addressed hydration transfer (router query() pattern) Serialize cache entries under sq:<queryHash> at fetch-dispatch time (provider-side, promise-valued so streaming settles ride the payload) instead of tying transfer to a rendered node's positional id. Client hooks look their own hash up and prime through query-core hydrate(); the registry outlives the hydration window, so prefetched-never-rendered queries transfer and late mounts (lazy routes, post-hydration navigation) adopt the server payload instead of refetching — restoring full cache-level dehydration coverage with less machinery. Priming moved ahead of the attach render effect (its effect half runs synchronously inside an active flush, and mount policy against a cold cache would refetch). Drops the peekNextChildId dependency; the data root reverts to { value }. Co-authored-by: Cursor <cursoragent@cursor.com> * chore(solid-query): drop internal porting notes from the tree Co-authored-by: Cursor <cursoragent@cursor.com> * refactor(solid-query)!: remove create* aliases, completing the #8950 deprecation The create*/Create* names were kept as a migration bridge when v5 made use* canonical (#8950 deprecated them). This major already rewrites every callsite's semantics, so the bridge retires: use* is the only naming, matching the docs. Co-authored-by: Cursor <cursoragent@cursor.com> * ci: apply automated fixes * refactor(solid-query)!: drop isInitialLoading (deprecated alias of isLoading) Core deprecated it in favor of isLoading; the adapter's getter was byte-identical. Result types now omit it (distributively over the Defined result unions so status discriminants survive), and useBaseQuery declares the adapter's own result face instead of the core union. Co-authored-by: Cursor <cursoragent@cursor.com> * chore(solid-query): require solid-js >= 2.0.0-rc.4 rc.4 is published and carries the hydration-end divergence takeover the adapter's streaming hydration relies on. Bump the peer range and dev dep off the locally-built solid and onto the released bits; full suite (344 adapter + 7 persist-client tests, typecheck) green against published rc.4. Co-authored-by: Cursor <cursoragent@cursor.com> --------- Co-authored-by: Cursor <cursoragent@cursor.com> Co-authored-by: autofix-ci[bot] <114827586+autofix-ci[bot]@users.noreply.github.com> Co-authored-by: Brenley Dueck <brenleydueck@gmail.com> Co-authored-by: Claude Opus 5 <noreply@anthropic.com>
by Ryan Carniato
Succeeded
11308
aef121ae chore(solid-query): require solid-js >= 2.0.0-rc.4 rc.4 is published and carries the hydration-end divergence takeover the adapter's streaming hydration relies on. Bump the peer range and dev dep off the locally-built solid and onto the released bits; full suite (344 adapter + 7 persist-client tests, typecheck) green against published rc.4. Co-authored-by: Cursor <cursoragent@cursor.com>
by Ryan Carniato
Succeeded
11308
94480d68 refactor(solid-query)!: remove create* aliases, completing the #8950 deprecation The create*/Create* names were kept as a migration bridge when v5 made use* canonical (#8950 deprecated them). This major already rewrites every callsite's semantics, so the bridge retires: use* is the only naming, matching the docs. Co-authored-by: Cursor <cursoragent@cursor.com>
by Ryan Carniato
Canceled
11308
94480d68 refactor(solid-query)!: remove create* aliases, completing the #8950 deprecation The create*/Create* names were kept as a migration bridge when v5 made use* canonical (#8950 deprecated them). This major already rewrites every callsite's semantics, so the bridge retires: use* is the only naming, matching the docs. Co-authored-by: Cursor <cursoragent@cursor.com>
by Ryan Carniato
Succeeded
feat/solid-query-v6-native-rewrite
97d43be3 Merge 8ffe8235759a0e14a3518ac5856f3224ea2c2559 into 606d09d369b4ff54514747b2bb49fe610d115e2e
by Ryan Carniato
Canceled
11308
4b8e5c1b feat(solid-query): serve data through an auto-reconciling store projection Solid 2 projections auto-reconcile their returns by key, so the data face becomes a store: deep reads are fine-grained and item identity survives across refetches (keyed by the new `reconcile` option, default 'id'). The async memo remains the SSR/hydration spine underneath; the projection derive is inert on the server — server projections run eagerly at creation, so a live derive would fetch at hook creation and serialize a duplicate payload, and the serialized entry would latch the hydrating client's projection for the whole stream. With nothing serialized the client projection computes live through the hydration window. Rewrites the structural-sharing test to the stronger store contract and adds leaf-granularity, custom-key, and primitive-data semantics tests. Co-authored-by: Cursor <cursoragent@cursor.com>
by Ryan Carniato
Failed
11308
4b8e5c1b feat(solid-query): serve data through an auto-reconciling store projection Solid 2 projections auto-reconcile their returns by key, so the data face becomes a store: deep reads are fine-grained and item identity survives across refetches (keyed by the new `reconcile` option, default 'id'). The async memo remains the SSR/hydration spine underneath; the projection derive is inert on the server — server projections run eagerly at creation, so a live derive would fetch at hook creation and serialize a duplicate payload, and the serialized entry would latch the hydrating client's projection for the whole stream. With nothing serialized the client projection computes live through the hydration window. Rewrites the structural-sharing test to the stronger store contract and adds leaf-granularity, custom-key, and primitive-data semantics tests. Co-authored-by: Cursor <cursoragent@cursor.com>
by Ryan Carniato
Failed
11308
b3621399 feat(solid-query): rewrite the adapter onto Solid 2's native async model Reads become a single async memo over the query cache (suspends into <Loading>, holds previous data through refetches, routes rejections to <Errored>, serializes settled values for streaming hydration); mutations ride Solid core's `action` primitive with transactional settle and optimistic overlays; cross-cache hooks share a dual-write aggregate with a hydration latch. The observer notification/store layer (createStore/reconcile, tracking proxies, notifyManager batching) is deleted — QueryObserver/MutationObserver remain as lifecycle/policy engines with noop listeners. Breaking: result `data` is non-optional (reads suspend instead of returning undefined), mutateAsync is removed (mutate returns a promise), and the reconcile/suspense/deferStream options are removed. SSR contracts pinned by the fixture suite: settled-only serialization for every exposed field, hydration id parity, no fetches inside the hydration/restore windows, and hydration-latched cross-cache aggregates. Validated against solid-js 2.0.0-rc.0 and rc.3, including an end-to-end template run with single-flight mutations. Co-authored-by: Cursor <cursoragent@cursor.com>
by Ryan Carniato