Organize Iris support files

TODO

@@ -1,40 +1,75 @@
-images
-    settings (sampler)
+# iris: known problems and things still to build
 
-text
-    figure out ways to speed up / what costs the most
-    resizing (per frame) is really slow (assuming painter isn't griefing)
-    j is weird / fix x offset
+Only open Iris framework work lives here. Delete an item when it lands.
 
-masks r just made to bare minimum work
+## Build (for the port)
 
-scaling
-    could be just a simple scaling factor that multiplies abs
-    and need to ensure text uses raw abs and not scaled abs
-    naming? (pt, px)
-    want to keep (drawn) regions using px? or should I add another field to UiScalar/Vec
-    field could be best solution so redrawing stuff isn't needed & you can specify both as user
+Framework capabilities needed by `RUST.md`'s port plan:
 
-WidgetRef<W> or smth instead of Id
-    enum that's either an Id or an actual concrete instance of W
-    painter takes them in instead of (or in addition to) id
-    then type wrapper widgets to contain them
-    allows for compile time optimization if a widget wrapper's inner is known at compile time
-        and the id of inner is not needed anywhere
-    maybe introduce InnerWidget trait to allow for editors to expose & modify inner type
-    maybe could also store a parent widget and keep using InnerWidget trait? unsure if possible
+- [ ] **Overflow ellipsis with an explicit retained end.** `TextAttrs` can
+  only wrap or clip, so a tool summary is cut with no mark. Parley has no
+  ellipsis primitive; use its line breaker to find the cut, but keep source
+  and displayed strings distinct with one byte mapping shared by spans,
+  links, selection and editing. Replace `wrap: bool` with an enum that can
+  say wrap, clip, head ellipsis and tail ellipsis—the caller must choose
+  because a command is identified by its head and a path by its tail.
+- [ ] **Expose the distance from a `LazySpan` viewport to its unloaded
+  edge.** (**P1**.) `viewport_len` and the visible extents are already
+  measured internally, but a paging caller cannot ask whether it is within
+  the product's six-viewport `HISTORY_SCREENS` cushion. The API should
+  answer in pixels or viewport multiples, never rows: a row ranges from one
+  line to a screen, so a fixed row count is not a distance.
+- [ ] **Let an image fit a bounded box while preserving its aspect ratio.**
+  (**P1**.) `Image` currently always reports and draws the decoded texture's
+  natural pixel size. Decoding and fetching a server-produced attachment
+  belong in `app`; iris only owes the generic fit/scale widget used to
+  draw its thumbnail.
+- [ ] **Per-range backgrounds for rich text.** (**P1**.) Inline code is
+  already monospace and coloured, but the inline-code chip also needs
+  the glyph run's boxes so a surface can be drawn behind exactly that byte
+  range. The shared `TextSelection` engine already computes the same geometry
+  for selection highlights; expose one shared primitive rather than giving
+  the app a second text-layout path.
+- [ ] **A horizontal gauge/bar widget.** (**P1**.) For
+  `SessionUsageBar`'s equivalent — a bounded fill reflecting a fraction,
+  nothing fancier.
+- [ ] **A toggle switch.** (**P3**.) For the delete dialog's
+  `deleteForeign` control; iris has no switch/checkbox widget yet as far
+  as this pass found.
 
-really weird limitation:
-    I don't think you can currently remove an element from a parent and put it in a child of the same parent
-    because it removes the unused children after the entire parent redraw
-    but the child gets drawn during that, so it will think the child is still active !!!
-    or something like that idk, maybe I need a special enum for parent that includes a undecided state where it may or may not get redrawn by the parent
-    or just do ref counting and ensure all drawn things == 1 afterwards (seems like best way)
-    ok so I'm removing the limit for now
+## Later
 
-don't forget I'm streaming
+- [ ] **Intern independently constructed solid paint definitions.** Inline
+  `rect(Srgba8::...)` values currently receive a new `PaintId` each time.
+  Cache them by canonical linear RGBA bits, but keep `Paints::add` explicitly
+  unique so two semantic theme roles that start with the same value can later
+  change independently. Cache entries must be weak and disappear when the
+  last real handle releases the slot; gradients and texture paints need their
+  own identity rules rather than inheriting solid-value interning blindly.
 
-tags
-vecs for each widget type?
+- [ ] **Property/content animations.** Cosmetic, so after correctness and
+  parity. Keep them modular, like input; scrolling already animates through
+  `Widget::tick` and `UiData::animate`. A widget that does not opt in must
+  pay nothing and import nothing for them.
 
-POTENTIAL BUG: closures that store IDs will not decrement the id!!! need to not increment id if moved into closure somehow??? wait no, need to decrement ID every time an event fn is added...... only if the id is used in it..??
+- [ ] **Remove `WidgetView` unless a real composite adopts it.** Every
+  composite in `app/src/ui` uses ordinary child handles plus a root;
+  `WidgetView` and its derive are used only by `iris/examples/view/lib.rs`.
+  It currently demonstrates itself rather than shortening production code.
+
+- [ ] **A `Stack` that chooses its mask the way it chooses its size
+  should replace `masked_by`.** For a square-cornered surface,
+  `.background(rect(BAR_FILL)).masked()` was measured
+  against `.masked_by(rect(BAR_FILL))` on the composer at the phone's own
+  size and density and the two are identical to the pixel. What the pair
+  cannot express is a clip that is not a box: `Painter::set_mask` writes
+  a `RectPrimitive::color` using `PaintId::NONE` at the widget's own region,
+  with no radius, so `.background(rect(fill).radius(r)).masked()` draws a
+  rounded panel and then cuts its content square. Both other call sites
+  (`row.rs`'s fence, `tool.rs`'s raw output) are rounded, which is why
+  the method stands for now.
+  Let `Stack` name the mask child the way `StackSize::Child(n)` names the
+  sizing child. Then `.background(x)` remains the one way to add a surface
+  and clipping to it is a stack property; the named mask child must have
+  drawn before any child that uses it. Once that exists, delete
+  `masked_by` and `Masked::shape` rather than retaining two APIs.