iris is the framework alone; the app is one crate in app-rust/

Iris: "the organization of the rust rewrite is a mess right now... there
shouldn't be anything related to the app inside of iris. Iris is supposed
to be the UI framework alone." And, on the crate count: "I'm confused why
the app only code needs more than one crate though."

Nine cargo workspaces become three, and the port's project code -- which
sat in five places, four of them inside the framework -- becomes one crate,
`ai-app`, in `app-rust/`:

  client-core                -> app-rust/src/client
  iris/transcript-ui         -> app-rust/src/ui
  iris/transcript-fixture    -> app-rust/src/ui/fixture.rs + tests/ + touch/
  iris/desktop-app           -> app-rust/src/desktop + src/bin_desktop.rs
  iris/android-app           -> app-rust/src/android + android-project/
  android-shell              -> app-rust/src/shell

iris/ keeps core, macro, the iris crate, tabs-ui and rig-input, and now
mentions no session, transcript, setup or server anywhere.

Only two of the old splits had a reason that survived reading. event-model
stays a crate at the repo root because server/ depends on it too, so a
crate is what makes the backend and the app agree by construction. The two
Android .so names looked like a hard constraint -- a package produces one
library artifact -- until P2 turned out to already plan merging those two
Android apps into one; both faces now come out of libai_app.so, picked
apart by features so `--no-default-features --features shell` keeps wgpu,
parley and iris out of the Compose app's APK. docs/RUST.md's "One app
crate" has the rest, including what each remaining feature is for.

DECISIONS.md and SUBAGENTS.md move into docs/ with everything else.

Verified: ./run-tests.sh and `cd iris && cargo test` green, clippy and fmt
clean in all five workspaces, `cargo ndk -t x86_64` links libai_app.so,
build-apk.sh produces an APK that installs and launches on this checkout's
emulator (Gl ... virgl, as expected), and the phone-sized headless
screenshot renders the transcript unchanged.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

src/state.rs

@@ -0,0 +1,112 @@
+use iris_core::{
+    UiRsc, WidgetId,
+    util::{HashMap, HashSet},
+};
+use iris_core::{WeakWidget, Widget};
+use std::{
+    any::{Any, TypeId},
+    marker::PhantomData,
+};
+
+#[derive(Clone, Copy, PartialEq, Eq, Hash)]
+struct Key {
+    id: WidgetId,
+    ty: TypeId,
+    i: usize,
+}
+
+#[derive(Default)]
+pub struct WidgetState {
+    widgets: HashMap<WidgetId, HashSet<(TypeId, usize)>>,
+    counts: HashMap<(WidgetId, TypeId), usize>,
+    map: HashMap<Key, Box<dyn Any>>,
+}
+
+impl WidgetState {
+    pub fn new() -> Self {
+        Self::default()
+    }
+    pub fn add<T: 'static>(&mut self, id: WidgetId, data: T) -> WeakState<T> {
+        let ty = TypeId::of::<T>();
+        let count = self.counts.entry((id, ty)).or_default();
+        let i = *count;
+        let key = Key { ty, i, id };
+        self.map.insert(key, Box::new(data));
+        self.widgets.entry(id).or_default().insert((ty, i));
+        *count += 1;
+        WeakState {
+            key,
+            _pd: PhantomData,
+        }
+    }
+    pub fn remove(&mut self, id: WidgetId) {
+        for &(ty, i) in self.widgets.get(&id).into_iter().flatten() {
+            self.map.remove(&Key { id, ty, i });
+        }
+    }
+    pub fn get<T: 'static>(&self, state: WeakState<T>) -> &T {
+        self.map.get(&state.key).unwrap().downcast_ref().unwrap()
+    }
+    pub fn get_mut<T: 'static>(&mut self, state: WeakState<T>) -> &mut T {
+        self.map
+            .get_mut(&state.key)
+            .unwrap()
+            .downcast_mut()
+            .unwrap()
+    }
+}
+
+#[derive(Clone, Copy)]
+pub struct WeakState<T> {
+    key: Key,
+    _pd: PhantomData<T>,
+}
+
+pub trait HasWidgetState {
+    fn widget_state(&self) -> &WidgetState;
+    fn widget_state_mut(&mut self) -> &mut WidgetState;
+}
+
+impl<'a, T: 'static> FnOnce<(&'a mut WidgetState,)> for WeakState<T> {
+    type Output = &'a mut T;
+
+    extern "rust-call" fn call_once(self, (state,): (&'a mut WidgetState,)) -> Self::Output {
+        state.get_mut(self)
+    }
+}
+
+/// What `Rsc[weak_handle]` indexes through -- one impl per kind of handle
+/// (a widget, a piece of per-widget state), shared by both backends' `Rsc`
+/// types since indexing a widget tree has nothing to do with windowing.
+/// Each backend still needs its own `Index`/`IndexMut for ItsRsc<State>`
+/// (`default/mod.rs`, `android/view.rs`), because a blanket impl over every
+/// `I: RscIdx<Rsc>` for every possible `Rsc` would conflict between crates.
+pub trait RscIdx<Rsc> {
+    type Output;
+    fn get(self, rsc: &Rsc) -> &Self::Output;
+    fn get_mut(self, rsc: &mut Rsc) -> &mut Self::Output;
+}
+
+impl<W: Widget, Rsc: UiRsc> RscIdx<Rsc> for WeakWidget<W> {
+    type Output = W;
+
+    fn get(self, rsc: &Rsc) -> &Self::Output {
+        &rsc.ui().widgets[self]
+    }
+
+    fn get_mut(self, rsc: &mut Rsc) -> &mut Self::Output {
+        &mut rsc.ui_mut().widgets[self]
+    }
+}
+
+impl<T: 'static, Rsc: HasWidgetState> RscIdx<Rsc> for WeakState<T> {
+    type Output = T;
+
+    fn get(self, rsc: &Rsc) -> &Self::Output {
+        rsc.widget_state().get(self)
+    }
+
+    fn get_mut(self, rsc: &mut Rsc) -> &mut Self::Output {
+        rsc.widget_state_mut().get_mut(self)
+    }
+}