@solidrt/core 0.0.51 → 0.0.53

package/src/gpu.ts

@@ -11,11 +11,14 @@
 // `flux:gpu` module.
 //
 // Sampling is a per-texture property declared at creation: `filter`
-// ("linear" default | "nearest") and `wrap` ("clamp" default | "repeat") on
-// every create* helper. One state for every consumer - `<texture>` display
-// and shader sampling both follow it - so a nearest texture upscales with
-// hard pixels everywhere (the retro/pixel-art path: render small, display
-// big). No mipmaps exist.
+// ("linear" default | "nearest"), `wrap` ("clamp" default | "repeat") and
+// `mipmap` (default false) on every create* helper. One state for every
+// consumer - `<texture>` display and shader sampling both follow it - so a
+// nearest texture upscales with hard pixels everywhere (the retro/pixel-art
+// path: render small, display big). `mipmap: true` keeps a mip chain the
+// runtime regenerates after every upload or render, so shader sampling of a
+// minified texture (3d surfaces at distance, a supersampled target) does
+// not alias; the display draw samples the full-size level only.
 //
 // Combining several passes is a render-tree job, not a shader one: stack
 // `<texture>` elements and set their `blendMode` (e.g. `blendMode="plus"` for
@@ -39,7 +42,10 @@
 //   multiplied by its A - `vec4(rgb * a, a)`, not `vec4(rgb, a)`, which
 //   composites as opaque. That is what Impeller composites and what
 //   `<texture blendMode>` blends; `clearColor` is premultiplied too, so the
-//   default transparent black needs no thought.
+//   default transparent black needs no thought. Uploaded pixels follow the
+//   same rule: `decodeImage` premultiplies at the codec boundary (image
+//   files store straight alpha) and `encodeImage` undoes it, so pixels
+//   inside the app are premultiplied everywhere.
 // - Values are non-linear RGBA8, with no color-space concept. Every texture
 //   and target holds 8-bit RGBA UNORM exactly as written; nothing converts to
 //   or from linear light. `filter: "linear"` averages and the `blend` modes
@@ -62,8 +68,8 @@ export type CreateOptions = { autoFree?: boolean; label?: string }
 
 // Sampling options every texture-producing create* helper accepts, applied at
 // creation as a property of the texture id (there is no set-sampler-later).
-export type SamplerOptions = { filter?: gpu.FilterMode; wrap?: gpu.WrapMode }
-export type { FilterMode, WrapMode } from "flux:gpu"
+export type SamplerOptions = { filter?: gpu.FilterMode; wrap?: gpu.WrapMode; mipmap?: boolean }
+export type { FilterMode, WrapMode, TextureBinding, TextureBindings } from "flux:gpu"
 
 // Pixel format option for the pixel-upload creates (createTexture,
 // createMutableTexture), fixed for the id's lifetime like the sampler state.
@@ -98,11 +104,16 @@ export type { BufferId, DrawId, ProgramId, RenderPipelineId, ShaderStageId, Text
 // resize in place at a stable id (so `<texture src>` and sampler bindings
 // stay valid); because the id survives, the owner-scoped auto-free
 // registered at creation keeps working and no re-registration is needed.
+// depthTexture(target) names a draw target's sampleable depth (created with
+// `depth: "texture"`): a sampler-only id bound like any texture, owned by
+// the target - no auto-free of its own, it dies with the target's.
 export {
+  depthTexture,
   destroyTexture,
   endBufferWrite,
   resizeTexture,
   setTargetParams,
+  setTargetRect,
   setTargetSize,
   setTargetTextures,
   uploadTexture,
@@ -112,7 +123,9 @@ export {
 // updated draw range (vertexCount after its buffer gained or lost dynamic
 // geometry, firstVertex for a different window of a shared buffer,
 // instanceCount for an instanced population; absent keys keep their current
-// value, like params); destroyBuffer is the manual
+// value, like params) and/or swapped buffers (instanceBuffer pointed at a
+// larger buffer once a population outgrows the old one - the growth
+// primitive; replace-only, the range is rechecked); destroyBuffer is the manual
 // cleanup path for buffers created outside a reactive scope. renderTarget is
 // the explicit render verb for `render: "manual"` targets - targets whose
 // pass is state (accumulation, feedback) rather than a pure function of its
@@ -122,22 +135,22 @@ export {
 // GPU-side (exact, same size): seed a loadOp "load" accumulator, snapshot a
 // ping-pong buffer, reset state to a known image.
 export { copyTexture, destroyBuffer, renderTarget, setDraw } from "flux:gpu"
-export type { BlendMode, CullMode, DrawRange, IndexBinding, IndexFormat, IndexRange, ShaderParams, Topology, VertexAttribute } from "flux:gpu"
+export type { BlendMode, BufferUpdate, CullMode, DrawRange, IndexBinding, IndexFormat, IndexRange, InstanceAttribute, ShaderParams, Topology, VertexAttribute } from "flux:gpu"
 
 // The draw-list verbs, re-exported raw: entries live and die with their draw
 // target (see createDrawTarget below), so there is no per-entry lifetime to
 // wrap. addDraw adds an entry (appended, or inserted via opts.before) and
 // returns its stable DrawId; removeDraw drops one; setDrawParams /
-// setDrawTextures / setDrawRange are the per-entry forms of setTargetParams /
-// setTargetTextures / setDraw, taking (target, draw, value) with identical
-// merge and validation semantics. The per-object hot path is setDrawParams (a
+// setDrawTextures / setDrawRange / setDrawBuffers are the per-entry forms of
+// setTargetParams / setTargetTextures / setDraw (its range and buffer halves),
+// taking (target, draw, value) with identical merge and validation semantics. The per-object hot path is setDrawParams (a
 // moved mesh = one call with its new matrix); the per-target one is
 // setTargetParams (exported above), which on a draw target writes the SHARED
 // params every entry reads. setDrawOrder replaces the whole
 // list order with a full permutation of the live ids - the sorting verb
 // (opaque front-to-back, transparent back-to-front, re-issued when the
 // camera moves).
-export { addDraw, removeDraw, setDrawOrder, setDrawParams, setDrawRange, setDrawTextures } from "flux:gpu"
+export { addDraw, removeDraw, setDrawBuffers, setDrawOrder, setDrawParams, setDrawRange, setDrawTextures } from "flux:gpu"
 
 // The device ceilings (max texture/target size, sampler inputs per pass,
 // vertex attributes per pipeline), queried once at startup. Creates and binds
@@ -162,6 +175,7 @@ export {
   destroyRenderPipeline,
   destroyShader,
   linkProgram,
+  programAttributes,
 } from "flux:gpu"
 
 /**
@@ -203,7 +217,9 @@ export { captureSnapshot, readTexture } from "flux:gpu"
  * Uploads raw pixels to an immutable GPU texture and returns its id (use it
  * as `<texture src={id} />`). `data` must be exactly `width * height` pixels
  * at the declared format's size (`* 4` bytes for the default "rgba8", `* 1`
- * for "r8"); a mismatch throws. For pixels you intend to mutate and
+ * for "r8"); a mismatch throws. RGBA data is uploaded verbatim and composited
+ * as premultiplied alpha, like every texture: `decodeImage` and the readback
+ * calls already deliver that, and hand-built pixels must too (`rgb * a`). For pixels you intend to mutate and
  * re-upload, use `createMutableTexture` instead. When called inside a
  * reactive scope the texture is freed automatically once that owner is
  * disposed; when called outside one (e.g. after an `await`, where the owner
@@ -283,7 +299,7 @@ export function createShaderTexture(
   width: number,
   height: number,
   params?: gpu.ShaderParams | null,
-  opts?: CreateOptions & SamplerOptions & { textures?: Record<string, gpu.TextureId> },
+  opts?: CreateOptions & SamplerOptions & { textures?: gpu.TextureBindings },
 ): gpu.TextureId {
   let id = gpu.createShaderTexture(fragmentSrc, width, height, params, opts)
   if (opts?.autoFree !== false && getOwner()) onCleanup(() => gpu.destroyTexture(id))
@@ -320,6 +336,12 @@ export function createShaderTexture(
  * the default `"clear"` clears to `clearColor` per render; state that must
  * read its own pixels (decay, blur, simulation) still ping-pongs across two
  * manual targets, and `copyTexture` seeds either shape.
+ *
+ * `samples` (2, 4 or 8) multisamples the target's storage so filled
+ * geometry gets anti-aliased edges; the texture id still names a
+ * single-sample image, so nothing downstream changes. Clamped to the device
+ * maximum, falls back to single-sample (with a warning) where the driver
+ * refuses, and throws with `loadOp: "load"`.
  */
 export function createShaderTarget(
   pipeline: gpu.RenderPipelineId,
@@ -327,12 +349,16 @@ export function createShaderTarget(
   height: number,
   params?: gpu.ShaderParams | null,
   opts?: {
-    textures?: Record<string, gpu.TextureId>
+    textures?: gpu.TextureBindings
     buffer?: gpu.BufferId
     instanceBuffer?: gpu.BufferId
+    /** One buffer per instance slot of the pipeline (index = the
+     * attributes' `slot`); pass this OR `instanceBuffer`, not both. */
+    instanceBuffers?: gpu.BufferId[]
     clearColor?: [number, number, number, number]
     render?: "auto" | "manual"
     loadOp?: "clear" | "load"
+    samples?: 1 | 2 | 4 | 8
   } & (gpu.DrawRange | (gpu.IndexBinding & gpu.IndexRange)) &
     CreateOptions &
     SamplerOptions,
@@ -352,7 +378,10 @@ export function createShaderTarget(
  * `setDrawParams` / `setDrawTextures` / `setDrawRange`. `depth: true` gives
  * the target the depth storage all entries share (cross-entry occlusion);
  * whether an entry tests/writes it stays pipeline state, and a depth-testing
- * pipeline into a depthless target throws at `addDraw`.
+ * pipeline into a depthless target throws at `addDraw`. `depth: "texture"`
+ * makes that storage a sampleable depth texture with its own id,
+ * `depthTexture(target)` - the shadow-map / depth-effect input; not with
+ * `samples`.
  *
  * `params` seeds the target's SHARED params - values every entry reads,
  * written once per target instead of once per entry (a camera's
@@ -366,6 +395,13 @@ export function createShaderTarget(
  * driven later with `setTargetTextures`, same precedence and coverage
  * rules.
  *
+ * `into` makes a sub-target: a draw target rendering into the rectangle at
+ * `x`/`y` (top-left origin) of draw target `into`'s storage, so N views or
+ * N shadow maps share one texture and ONE pass; the id is a draw target to
+ * every verb but not a texture (display and sample the parent, with
+ * `srcX`/`srcY` on the leaf), and `setTargetRect` moves it. Auto-free works
+ * the same way; destroying the parent takes its tiles.
+ *
  * The render contract is unchanged: the list is input data, so an ordinary
  * (`render: "auto"`) draw target re-renders exactly when its entries or
  * their inputs change - a static scene costs zero passes, and one render is
@@ -379,11 +415,15 @@ export function createDrawTarget(
   height: number,
   params?: gpu.ShaderParams | null,
   opts?: {
-    depth?: boolean
-    textures?: Record<string, gpu.TextureId>
+    depth?: boolean | "texture"
+    textures?: gpu.TextureBindings
     clearColor?: [number, number, number, number]
     render?: "auto" | "manual"
     loadOp?: "clear" | "load"
+    samples?: 1 | 2 | 4 | 8
+    into?: gpu.TextureId
+    x?: number
+    y?: number
   } & CreateOptions &
     SamplerOptions,
 ): gpu.TextureId {
@@ -393,29 +433,31 @@ export function createDrawTarget(
 }
 
 /** The reactive shader description `createShaderTextureMemo` builds from.
- * Sampling (`filter`/`wrap`) is creation-time state, so changing it rebuilds
+ * Sampling (`filter`/`wrap`/`mipmap`) is creation-time state, so changing it rebuilds
  * at a fresh id, like a fragment-source or sampler-binding change. */
 export type ShaderSpec = {
   fragmentSrc: string
   width: number
   height: number
   params?: gpu.ShaderParams
-  textures?: Record<string, gpu.TextureId>
+  textures?: gpu.TextureBindings
 } & SamplerOptions
 
 // Shallow name->value equality for params/textures records; treats undefined
 // as the empty record. A param value may be a number or a flat number array
-// (typed uniforms), so arrays compare elementwise.
-function sameValue(a: number | number[] | undefined, b: number | number[] | undefined): boolean {
+// (typed uniforms), so arrays compare elementwise; a texture binding may be
+// an `{ id, filter?, wrap? }` override, compared field by field.
+type RecordValue = number | number[] | gpu.TextureBinding
+function sameValue(a: RecordValue | undefined, b: RecordValue | undefined): boolean {
   if (a === b) return true
-  if (!Array.isArray(a) || !Array.isArray(b)) return false
-  return a.length === b.length && a.every((v, i) => v === b[i])
+  if (Array.isArray(a) && Array.isArray(b)) return a.length === b.length && a.every((v, i) => v === b[i])
+  if (typeof a === "object" && typeof b === "object" && !Array.isArray(a) && !Array.isArray(b)) {
+    return a.id === b.id && a.filter === b.filter && a.wrap === b.wrap
+  }
+  return false
 }
 
-function sameRecord(
-  a: Record<string, number | number[]> | undefined,
-  b: Record<string, number | number[]> | undefined,
-): boolean {
+function sameRecord(a: Record<string, RecordValue> | undefined, b: Record<string, RecordValue> | undefined): boolean {
   if (a === b) return true
   let ka = a ? Object.keys(a) : []
   let kb = b ? Object.keys(b) : []
@@ -450,7 +492,12 @@ export function createShaderTextureMemo(
   opts?: { onError?: (error: unknown) => void },
 ): () => gpu.TextureId {
   let make = (s: ShaderSpec) =>
-    gpu.createShaderTexture(s.fragmentSrc, s.width, s.height, s.params, { textures: s.textures, filter: s.filter, wrap: s.wrap })
+    gpu.createShaderTexture(s.fragmentSrc, s.width, s.height, s.params, {
+      textures: s.textures,
+      filter: s.filter,
+      wrap: s.wrap,
+      mipmap: s.mipmap,
+    })
   let current = untrack(spec)
   let currentId = make(current)
   let [id, setId] = createSignal(currentId)
@@ -460,7 +507,8 @@ export function createShaderTextureMemo(
         next.fragmentSrc === current.fragmentSrc &&
         sameRecord(next.textures, current.textures) &&
         next.filter === current.filter &&
-        next.wrap === current.wrap
+        next.wrap === current.wrap &&
+        next.mipmap === current.mipmap
       ) {
         // Program and inputs unchanged: mutate in place, the id stays stable.
         if (next.width !== current.width || next.height !== current.height) {
@@ -545,11 +593,14 @@ export function createPipelineTexture(
   height: number,
   params?: gpu.ShaderParams | null,
   opts?: {
-    textures?: Record<string, gpu.TextureId>
+    textures?: gpu.TextureBindings
     attributes?: gpu.VertexAttribute[]
     buffer?: gpu.BufferId
-    instanceAttributes?: gpu.VertexAttribute[]
+    instanceAttributes?: gpu.InstanceAttribute[]
     instanceBuffer?: gpu.BufferId
+    /** One buffer per instance slot (index = the attributes' `slot`);
+     * pass this OR `instanceBuffer`, not both. */
+    instanceBuffers?: gpu.BufferId[]
     topology?: gpu.Topology
     depth?: boolean
     depthWrite?: boolean
@@ -558,6 +609,7 @@ export function createPipelineTexture(
     clearColor?: [number, number, number, number]
     render?: "auto" | "manual"
     loadOp?: "clear" | "load"
+    samples?: 1 | 2 | 4 | 8
   } & (gpu.DrawRange | (gpu.IndexBinding & gpu.IndexRange)) &
     CreateOptions &
     SamplerOptions,

package/src/index.ts

@@ -1,5 +1,5 @@
 export * from "./renderer"
-export { setFocus, focusedNode, startTextInput, textInputActive, getFocusables, measureText, prepareText, layoutNextLine, unitInk, getBoundingBox, getBoundingBoxViewport, onPointerMove } from "./core"
+export { setFocus, focusedNode, startTextInput, textInputActive, getFocusables, measureText, prepareText, layoutNextLine, unitInk, getBoundingBox, getBoundingBoxViewport, snapshotTexture, onPointerMove } from "./core"
 export type { BoundingBox, GlobalPointerEvent, TextLine } from "./core"
 export { parseColor, mixColors, brightness, createLinearGradient, createRadialGradient } from "./color"
 export type { Gradient, GradientStop } from "./color"
@@ -17,9 +17,11 @@ export type { TextureId } from "./gpu"
 export { createImage, decodeImage, encodeImage } from "./image"
 export type { DecodedImage, ImageSource } from "./image"
 export { parseSvg, svg } from "./svg"
+export { Logo } from "./logo"
+export type { LogoProps } from "./logo"
 export type { SvgDocument, SvgDraw } from "./svg"
 export { createScroll } from "./scroll"
-export type { Scroll, ScrollAxis, ScrollOffset, ScrollOptions } from "./scroll"
+export type { Scroll, ScrollAxis, ScrollBehavior, ScrollOffset, ScrollOptions, ScrollToOptions } from "./scroll"
 export { arena } from "./arena"
 export type { ArenaOwner } from "./arena"
 export { createPan } from "./pan"
@@ -31,6 +33,10 @@ export type {
   LayoutProps,
   TransformProps,
   PointerProps,
+  TransitionProps,
+  Transition,
+  TransitionPropName,
+  TransitionEndEvent,
   PointerEvent,
   WheelEvent,
   KeyEvent,

package/src/logo.tsx

@@ -0,0 +1,92 @@
+// The SolidRT brand mark: seven puzzle segments authored in a 100x100 space,
+// each filled with its own light-to-dark gradient. Static by default; the
+// animated forms stagger a fade per segment, either once (fade in and hold)
+// or in a loop (in, then out, repeat) like the scaffold's welcome screen.
+import { For, Show, createSignal } from "solid-js"
+import { createLinearGradient } from "./color"
+import { onFrame } from "./window"
+
+export interface LogoProps {
+  // Rendered width and height in pixels; the mark is square. Default 100.
+  size?: number
+  // "none" draws the mark at full opacity and requests no frames (default).
+  // "once" fades the segments in one after the other and then holds; "loop"
+  // fades them in, then out, and repeats.
+  animation?: "none" | "once" | "loop"
+}
+
+// Per segment: the delay of its fade in ms (its fade out follows at the same
+// offset after the last fade in has completed), its gradient, its path.
+const SEGMENTS = [
+  { base: 0, light: "#3f5494", dark: "#162b6c", d: "M50.000 50.000 L28.330 50.000 C28.330 48.810 27.695 47.711 26.665 47.116 C25.635 46.521 24.365 46.521 23.335 47.116 C22.305 47.711 21.670 48.810 21.670 50.000 L0.000 50.000 L50.000 0.000 L50.000 9.170 C48.810 9.170 47.711 9.805 47.116 10.835 C46.521 11.865 46.521 13.135 47.116 14.165 C47.711 15.195 48.810 15.830 50.000 15.830 L50.000 25.000 L50.000 34.170 C48.810 34.170 47.711 34.805 47.116 35.835 C46.521 36.865 46.521 38.135 47.116 39.165 C47.711 40.195 48.810 40.830 50.000 40.830 L50.000 50.000 Z" },
+  { base: 90, light: "#547ebf", dark: "#2b5696", d: "M50.000 50.000 L50.000 59.170 C48.810 59.170 47.711 59.805 47.116 60.835 C46.521 61.865 46.521 63.135 47.116 64.165 C47.711 65.195 48.810 65.830 50.000 65.830 L50.000 75.000 L50.000 84.170 C48.810 84.170 47.711 84.805 47.116 85.835 C46.521 86.865 46.521 88.135 47.116 89.165 C47.711 90.195 48.810 90.830 50.000 90.830 L50.000 100.000 L0.000 50.000 L21.670 50.000 C21.670 48.810 22.305 47.711 23.335 47.116 C24.365 46.521 25.635 46.521 26.665 47.116 C27.695 47.711 28.330 48.810 28.330 50.000 L50.000 50.000 Z" },
+  { base: 180, light: "#7ea9ea", dark: "#5681c1", d: "M50.000 25.000 L50.000 15.830 C48.810 15.830 47.711 15.195 47.116 14.165 C46.521 13.135 46.521 11.865 47.116 10.835 C47.711 9.805 48.810 9.170 50.000 9.170 L50.000 0.000 L75.000 25.000 L65.830 25.000 C65.830 26.190 65.195 27.289 64.165 27.884 C63.135 28.479 61.865 28.479 60.835 27.884 C59.805 27.289 59.170 26.190 59.170 25.000 L50.000 25.000 Z" },
+  { base: 270, light: "#547ebf", dark: "#2b5696", d: "M50.000 25.000 L59.170 25.000 C59.170 26.190 59.805 27.289 60.835 27.884 C61.865 28.479 63.135 28.479 64.165 27.884 C65.195 27.289 65.830 26.190 65.830 25.000 L75.000 25.000 L75.000 34.170 C73.810 34.170 72.711 34.805 72.116 35.835 C71.521 36.865 71.521 38.135 72.116 39.165 C72.711 40.195 73.810 40.830 75.000 40.830 L75.000 50.000 L65.830 50.000 C65.830 48.810 65.195 47.711 64.165 47.116 C63.135 46.521 61.865 46.521 60.835 47.116 C59.805 47.711 59.170 48.810 59.170 50.000 L50.000 50.000 L50.000 40.830 C48.810 40.830 47.711 40.195 47.116 39.165 C46.521 38.135 46.521 36.865 47.116 35.835 C47.711 34.805 48.810 34.170 50.000 34.170 L50.000 25.000 Z" },
+  { base: 360, light: "#7ea9ea", dark: "#5681c1", d: "M50.000 50.000 L59.170 50.000 C59.170 48.810 59.805 47.711 60.835 47.116 C61.865 46.521 63.135 46.521 64.165 47.116 C65.195 47.711 65.830 48.810 65.830 50.000 L75.000 50.000 L64.855 60.145 C64.013 59.304 62.787 58.976 61.638 59.283 C60.489 59.591 59.591 60.489 59.283 61.638 C58.976 62.787 59.304 64.013 60.145 64.855 L50.000 75.000 L50.000 65.830 C48.810 65.830 47.711 65.195 47.116 64.165 C46.521 63.135 46.521 61.865 47.116 60.835 C47.711 59.805 48.810 59.170 50.000 59.170 L50.000 50.000 Z" },
+  { base: 450, light: "#3f5494", dark: "#162b6c", d: "M75.000 50.000 L75.000 59.170 C73.810 59.170 72.711 59.805 72.116 60.835 C71.521 61.865 71.521 63.135 72.116 64.165 C72.711 65.195 73.810 65.830 75.000 65.830 L75.000 75.000 L50.000 100.000 L50.000 90.830 C48.810 90.830 47.711 90.195 47.116 89.165 C46.521 88.135 46.521 86.865 47.116 85.835 C47.711 84.805 48.810 84.170 50.000 84.170 L50.000 75.000 L60.145 64.855 C59.304 64.013 58.976 62.787 59.283 61.638 C59.591 60.489 60.489 59.591 61.638 59.283 C62.787 58.976 64.013 59.304 64.855 60.145 L75.000 50.000 Z" },
+  { base: 540, light: "#7ea9ea", dark: "#5681c1", d: "M100.000 50.000 L75.000 75.000 L75.000 65.830 C73.810 65.830 72.711 65.195 72.116 64.165 C71.521 63.135 71.521 61.865 72.116 60.835 C72.711 59.805 73.810 59.170 75.000 59.170 L75.000 50.000 L75.000 40.830 C73.810 40.830 72.711 40.195 72.116 39.165 C71.521 38.135 71.521 36.865 72.116 35.835 C72.711 34.805 73.810 34.170 75.000 34.170 L75.000 25.000 L100.000 50.000 Z" },
+]
+
+const FADE = 360
+const LAST = SEGMENTS[SEGMENTS.length - 1]!.base
+// The whole mark is visible from IN_DONE; a loop cycle fades out after that.
+const IN_DONE = LAST + FADE
+const CYCLE = IN_DONE + LAST + FADE
+
+let clamp = (x: number) => (x < 0 ? 0 : x > 1 ? 1 : x)
+let ease = (t: number) => 1 - (1 - t) * (1 - t)
+let byte = (x: number) => Math.round(clamp(x) * 255).toString(16).padStart(2, "0")
+
+export function Logo(props: LogoProps) {
+  let size = () => props.size ?? 100
+  let mode = () => props.animation ?? "none"
+
+  // Elapsed animation time; only advanced while an animated mode is mounted.
+  let [clock, setClock] = createSignal(0)
+
+  // The frame loop is mounted through the <Show> below so a mode change
+  // remounts it: onFrame holds a standing frame request while registered.
+  // "once" releases its request as soon as the last segment is in.
+  let Animate = () => {
+    let start = -1
+    let stop = onFrame((tick) => {
+      if (start < 0) start = tick
+      let t = tick - start
+      if (mode() === "loop") setClock(t % CYCLE)
+      else if (t < IN_DONE) setClock(t)
+      else {
+        setClock(IN_DONE)
+        stop()
+      }
+    })
+    return null
+  }
+
+  let alpha = (seg: (typeof SEGMENTS)[number]) => {
+    if (mode() === "none") return 1
+    let t = clock()
+    if (t < seg.base) return 0
+    let fadeIn = clamp((t - seg.base) / FADE)
+    if (mode() === "once") return ease(fadeIn)
+    let end = IN_DONE + seg.base + FADE
+    if (t >= end) return 0
+    return ease(Math.min(fadeIn, clamp((end - t) / FADE)))
+  }
+
+  let fill = (seg: (typeof SEGMENTS)[number]) => {
+    let a = byte(alpha(seg))
+    return createLinearGradient(0, 0, 1, 1, [
+      { offset: 0, color: seg.light + a },
+      { offset: 1, color: seg.dark + a },
+    ])
+  }
+
+  return (
+    <view width={size()} height={size()} designSize={[100, 100]}>
+      <Show when={mode() !== "none"}>
+        <Animate />
+      </Show>
+      <For each={SEGMENTS}>{(seg) => <d-path d={seg.d} color={fill(seg)} />}</For>
+    </view>
+  )
+}