vireuikit 0.4.0 → 0.6.0

package/NOTICE

@@ -4,8 +4,5 @@ Copyright 2026 Danil Kotlaev
 This product includes software developed as part of the vireSpace platform
 (https://github.com/pruffit/vire).
 
-Built on VireGlass (https://github.com/pruffit/vireglass). The Oklab color-mixing math
-implements the model published by Björn Ottosson (https://bottosson.github.io/posts/oklab/).
-The MacCormack advection scheme implements the method described in Selle, Fedkiw, Kim, Liu and
-Rossignac, "An Unconditionally Stable MacCormack Method" (2007). No third-party code or assets
-are included in or distributed with this software; these are citations, not redistribution.
+Built on VireGlass (https://github.com/pruffit/vireglass). No third-party code or assets are
+included in or distributed with this software.

package/README.md

@@ -1,9 +1,8 @@
 # VireUIKit
 
 A UI kit built on top of [VireGlass](https://github.com/pruffit/vireglass)'s physically-derived
-glass material: atom state and press/hover/selection behavior for controls, a capsule-to-target
-growth morph, and a live GPU backdrop — a lit cloud-chamber: dark mist, static lights, and
-condensation tracks — that plugs into VireGlass's WebGL2 renderer as a backdrop pass.
+glass material: atom state and press/hover/selection behavior for controls, and a
+capsule-to-target growth morph.
 
 **Status: 0.x.** The API can still change between minor versions.
 
@@ -13,8 +12,8 @@ condensation tracks — that plugs into VireGlass's WebGL2 renderer as a backdro
 npm install vireuikit vireglass
 ```
 
-`vireglass` is a peer dependency — this package draws on its material model and its WebGL2 render
-pipeline rather than shipping its own.
+`vireglass` (3.x) is a peer dependency — this package draws on its material model rather than
+shipping its own.
 
 ## Atom state and morph
 
@@ -44,84 +43,60 @@ const frame = growthFrame(sourceShape, targetShape, anchorPoint, growthPhase(sta
 // frame.body: the shape to draw as glass this frame.
 ```
 
-## GPU backdrop: a lit chamber, not colored smoke
-
-`createMediumBackdrop()` returns a `VireGlassBackdropPass` factory: a self-contained fluid
-simulation (curl-noise vapor, condensing droplets, decaying condensation tracks) that composites
-straight into the texture VireGlass's lens samples — no offscreen canvas, no readback.
-
-The chamber itself is dark; what's visible is light scattered by vapor, droplets and tracks, not
-the gas's own color. `lights` (`VireUIKitMediumParams`, up to `MEDIUM_MAX_LIGHTS`) are static
-sources — position, direction, cone half-angle, falloff, color, intensity. The defaults are an edge
-strip along the chamber floor and two spotlights placed above the frame, aimed down across it. A
-spotlight has no drawn edge: its beam is a soft lobe with static shafts fanning out from the lamp,
-dimmed by the gas between the lamp and each point (a grid-resolution shadow pass,
-`shadowExtinction`), so beams show where there is vapor to scatter them. `lightRigForCover`/
-`lightRigForCharacter` tint the spotlights toward a cover's hue like colored gels and leave the
-strip near neutral. Vapor species (`channelColors`) fold into a near-neutral ambient base;
-`channelScatter` is how strongly each species scatters light.
-
-Tracks come in three kinds (`MEDIUM_TRACK_PRESETS`): `alpha` (short, thick, thickening toward its
-end — the playing source sprays a burst of them from the cover's position, a few on the beat and
-the rest over the next 1.6 s), `electron` (thin, wiggly) and `muon` (long, straight,
-thin). The calm state schedules a lone electron or muon every 8–20 s from no source at all. Each track is drawn twice: as a soft residue stamped into the simulation grid, and
-as a crisp droplet chain in content pixels (`trackLayerAmount`, `MEDIUM_TRACK_LAYER_LOOK`) that
-appears at full length, then broadens, sags and fades over one to two seconds. Tracks are lit by
-the same lights, plus `trackLightFloor` so one is never fully dark.
+## Web elements
+
+`vireuikit/web` upgrades native controls with custom elements. The control inside works before the
+upgrade; afterwards the element drives its states from the model. Glass is opt-in: put `glass` on pieces
+of the navigation layer, and leave it off for content.
+
+```html
+<vire-button><button>Play</button></vire-button>
+<vire-icon-button glass><button aria-label="Share">…</button></vire-icon-button>
+```
 
 ```ts
-import { createMediumBackdrop } from 'vireuikit/web';
-import { createVireGlassRenderer } from 'vireglass/web';
-
-const medium = createMediumBackdrop();
-const renderer = createVireGlassRenderer(canvas);
-renderer.resize(canvas.width, canvas.height);
-
-let last = performance.now();
-function frame(now: number) {
-  const dt = (now - last) / 1000;
-  last = now;
-  renderer.render({
-    density: window.devicePixelRatio,
-    debug: 'normal',
-    pieces,
-    backdrop: medium.pass({ gridWidth: 128, gridHeight: 72, dt }),
-  });
-  requestAnimationFrame(frame);
-}
+import { defineVireElements, setA11yOverride } from 'vireuikit/web';
+
+defineVireElements({ nonce: cspNonce });
+setA11yOverride({ reduceTransparency: true });
 ```
 
-Turbulence and light-track emission in response to playback come from `createMediumDynamics()`,
-which is platform-neutral: feed `step()` a playback state, BPM and a deterministic position, and
-pass the `emissions` it returns on as `MediumFrame.emissions`.
-
-The backdrop reads as a chamber seen from the side, not a flat field, without a second simulation:
-the composite samples the same vapor/condensate grid twice, once at identity and once at a larger
-scale and a fixed offset (`MEDIUM_DEFAULTS.depthFarScale`/`depthFarOffsetFrac`, the offset as a
-fraction of the grid so it stays clear of the wrap at any grid size) — the far read is both slower
-on screen and finer-grained, since the field's own motion maps to screen motion as `v / scale`. An
-8-tap rotated ring blur on that far read (`depthFarBlurRadius`) supplies aerial perspective's
-softness and lower contrast in the same pass, weighted down (`depthFarWeight`) so it never competes
-with the near plane; the ring (not an axis-aligned box) keeps that blur from turning a residual
-seam or resize artifact into parallel straight lines. Gravity is two separate properties: a small
-downward drift on vapor's own velocity (`gravityVaporDrift`, a motion cue only — a uniform drift on
-this periodic grid cannot itself accumulate density) and a compositing-only density boost near the
-bottom of the frame (`gravityBottomBoost`/`gravityBottomBoostStart`, a steady-state property that
-cannot affect the conserved water total) that actually produces the "denser at the bottom" reading.
-Condensate settling adds a second, always-on share of the ambient curl field's own sideways push
-(`condensateSettleWiggle`) so a droplet falling at a constant speed doesn't trace a dead-straight
-vertical line when turbulence is otherwise low. Each emitted track also carries a `depth` (0 far …
-1 near) that scales its own width and intensity, so a far track reads thinner, dimmer and finer,
-while the nearest tracks read a little LARGER than the base preset, not merely full-size — a
-Gaussian stamp's edge softness scales with its own width, so the same knob gives depth of field too.
-
-The curl-noise potential itself is periodic over the simulation grid in space, the same way it
-already was in time: each octave's spatial frequency is adjusted, per grid size, to the nearest
-value that makes a full grid width (or height) an exact integer number of lattice cells
-(`computeMediumSpatialPeriods`) — so velocity never jumps at the domain's own wrap, and the far
-plane's tile boundary reads as an ordinary point in the field rather than a seam. The near plane's
-vapor and condensate reads use cubic B-spline reconstruction (4 bilinear taps) instead of plain
-bilinear, so the simulation grid's own cells don't read as squares at typical (coarse) grid sizes.
+- `<vire-button>` is an action: it sinks and grows slightly under press, and nothing opens out of it.
+- `<vire-icon-button>` lifts into the glass under the finger; the lens response is visible while the
+  press is held.
+- Attributes: `glass` (empty or `present`: a lens at rest; `touch`: a lens only under the finger; absent: no
+  glass), `size` (`touch`, `small`, `medium`, `large`, `xlarge`; by default `touch` on a coarse pointer and
+  `medium` otherwise), `disabled`.
+- On a coarse pointer every size keeps a hit area of at least 44 dp without changing layout.
+- The lens reads the backdrop from declared colours and cannot see an image, a video or a canvas. A host that knows
+  what lies under the control sets the element's `sample` (a `BackdropSample` from `vireglass`), at any time; `null`
+  hands it back to the probe.
+
+  ```ts
+  import { statsFromSamples } from 'vireglass/dom';
+
+  playButton.sample = statsFromSamples(coverColours); // [{ r, g, b }, …] in 0–255
+  ```
+
+- The element dispatches `vire-glass-ready` once its lens is attached. If the lens cannot be loaded or attached,
+  the control stays a complete one on its plain (or, under reduced transparency, opaque frosted) surface, and the next
+  setting change tries again.
+- Set `disabled` on the host element: it is mirrored onto the inner `<button>` and wins over it. Clearing it on
+  the host re-enables the button.
+- Under `forced-colors` the elements keep the system colours and drop their own tints and blur.
+- Accessibility follows the system `prefers-*` settings; `setA11yOverride` or the element's `a11y`
+  property overrides them. Reduced transparency keeps the lens and frosts it: a blurrier lens and a denser body, with the
+  ink following the body. Text takes the page's colour; the frosted fallback and the high-contrast bodies assume
+  the page's `color-scheme` matches it.
+- The elements inject one stylesheet. Under a strict CSP pass `nonce` to `defineVireElements`, or ship the
+  exported `STYLES` string yourself.
+- Importing the module touches no DOM, so it is safe on a server; `defineVireElements()` is the only call
+  that registers anything. An element defined before its markup is parsed waits for its button.
+
+Sizes, behaviour state machines and accessibility modes are exported from `vireuikit` and shared by every
+target. How an atom is accepted:
+[design](https://github.com/pruffit/vireuikit/blob/main/docs/design.md),
+[acceptance](https://github.com/pruffit/vireuikit/blob/main/docs/acceptance.md).
 
 ## License
 

package/dist/a11y-D3SS74I3.d.cts

@@ -0,0 +1,25 @@
+type A11yMode = {
+    reduceTransparency: boolean;
+    increaseContrast: boolean;
+    reduceMotion: boolean;
+};
+declare const A11Y_NONE: A11yMode;
+/** `undefined` follows the system; a boolean overrides it. */
+type A11yOverride = {
+    [K in keyof A11yMode]?: boolean | undefined;
+};
+declare function resolveA11y(system: A11yMode, override?: A11yOverride): A11yMode;
+/** `plain`: no glass was asked for. `frosted`: the stand-in when glass under reduced transparency cannot attach. */
+type Surface = 'plain' | 'frosted' | 'glass';
+type Presentation = {
+    glass: boolean;
+    /** Reduced transparency: the glass stays and frosts. */
+    frost: boolean;
+    surface: Surface;
+    contrastBorder: boolean;
+    instantSprings: boolean;
+};
+declare function presentationFor(mode: A11yMode, wantsGlass: boolean): Presentation;
+declare function sameA11y(a: A11yMode, b: A11yMode): boolean;
+
+export { A11Y_NONE as A, type Presentation as P, type Surface as S, type A11yMode as a, type A11yOverride as b, presentationFor as p, resolveA11y as r, sameA11y as s };

package/dist/a11y-D3SS74I3.d.ts

@@ -0,0 +1,25 @@
+type A11yMode = {
+    reduceTransparency: boolean;
+    increaseContrast: boolean;
+    reduceMotion: boolean;
+};
+declare const A11Y_NONE: A11yMode;
+/** `undefined` follows the system; a boolean overrides it. */
+type A11yOverride = {
+    [K in keyof A11yMode]?: boolean | undefined;
+};
+declare function resolveA11y(system: A11yMode, override?: A11yOverride): A11yMode;
+/** `plain`: no glass was asked for. `frosted`: the stand-in when glass under reduced transparency cannot attach. */
+type Surface = 'plain' | 'frosted' | 'glass';
+type Presentation = {
+    glass: boolean;
+    /** Reduced transparency: the glass stays and frosts. */
+    frost: boolean;
+    surface: Surface;
+    contrastBorder: boolean;
+    instantSprings: boolean;
+};
+declare function presentationFor(mode: A11yMode, wantsGlass: boolean): Presentation;
+declare function sameA11y(a: A11yMode, b: A11yMode): boolean;
+
+export { A11Y_NONE as A, type Presentation as P, type Surface as S, type A11yMode as a, type A11yOverride as b, presentationFor as p, resolveA11y as r, sameA11y as s };

package/dist/chunk-I3BD3XGC.js

@@ -0,0 +1,392 @@
+import { activeMaterial, applyAccessibility, resolveOptics, halfMinDp, concentricRadius } from 'vireglass';
+
+// src/kit/a11y.ts
+var A11Y_NONE = {
+  reduceTransparency: false,
+  increaseContrast: false,
+  reduceMotion: false
+};
+function resolveA11y(system, override = {}) {
+  return {
+    reduceTransparency: override.reduceTransparency ?? system.reduceTransparency,
+    increaseContrast: override.increaseContrast ?? system.increaseContrast,
+    reduceMotion: override.reduceMotion ?? system.reduceMotion
+  };
+}
+function presentationFor(mode, wantsGlass) {
+  return {
+    glass: wantsGlass,
+    frost: wantsGlass && mode.reduceTransparency,
+    surface: wantsGlass ? "glass" : "plain",
+    contrastBorder: mode.increaseContrast,
+    instantSprings: mode.reduceMotion
+  };
+}
+function sameA11y(a, b) {
+  return a.reduceTransparency === b.reduceTransparency && a.increaseContrast === b.increaseContrast && a.reduceMotion === b.reduceMotion;
+}
+var ATOM_AT_REST = {
+  pressed: 0,
+  hovered: 0,
+  selected: 0,
+  disabled: false
+};
+function atomLift(kind) {
+  switch (kind) {
+    case "iconButton":
+    case "switch":
+    case "slider":
+      return 1;
+    default:
+      return 0;
+  }
+}
+var DISABLED_PRESENCE = 0.25;
+var HOVER_GAIN = 0.35;
+function activation(state) {
+  if (state.disabled) return 0;
+  const clamp = (v) => v < 0 ? 0 : v > 1 ? 1 : v;
+  return Math.max(clamp(state.selected), clamp(state.pressed), clamp(state.hovered) * HOVER_GAIN);
+}
+function atomMaterial(base, kind, state = ATOM_AT_REST) {
+  const out = activeMaterial(base, activation(state));
+  if (!state.disabled) return out;
+  return { ...out, presence: out.presence * DISABLED_PRESENCE };
+}
+function atomAtRest(state) {
+  return state.pressed === 0 && state.hovered === 0 && state.selected === 0 && state.disabled === false;
+}
+var REST_BODY = { alpha: 0.25, white: 0.15, lift: 0.1 };
+var PRESSED_BODY = { alpha: 0.34, white: 0.35, lift: 0 };
+var FROST_LIFT = 0.26;
+function atomBody(base, state = ATOM_AT_REST, frost = false) {
+  const on = activation(state);
+  const mix2 = (key) => REST_BODY[key] + (PRESSED_BODY[key] - REST_BODY[key]) * on;
+  let alpha = mix2("alpha");
+  let white = mix2("white");
+  let lift = mix2("lift");
+  if (state.disabled) alpha *= DISABLED_PRESENCE;
+  if (frost) {
+    const density = applyAccessibility(resolveOptics(base), {
+      reduceTransparency: true,
+      increaseContrast: false,
+      reduceMotion: false
+    }).bodyDensity;
+    alpha = Math.max(alpha, density);
+    white = 0;
+    lift = FROST_LIFT;
+  }
+  return { alpha, white, lift };
+}
+
+// src/kit/behavior/focus.ts
+function stepFocus(event) {
+  return event.type === "focus" && event.visible;
+}
+
+// src/kit/behavior/hover.ts
+function stepHover(event, canHover) {
+  return canHover && event.type === "enter";
+}
+
+// src/kit/behavior/press.ts
+var PRESS_IDLE = { by: null };
+function stepPress(state, event, enabled) {
+  switch (event.type) {
+    case "down":
+      if (!enabled || state.by !== null) return { state, activated: false };
+      return { state: { by: event.source }, activated: false };
+    case "up":
+      if (state.by !== event.source) return { state, activated: false };
+      return { state: PRESS_IDLE, activated: enabled };
+    case "cancel":
+      return { state: PRESS_IDLE, activated: false };
+    case "leave":
+      return state.by === "pointer" ? { state: PRESS_IDLE, activated: false } : { state, activated: false };
+  }
+}
+
+// src/kit/behavior/control.ts
+var TOUCH_INPUT = { hover: false };
+var POINTER_INPUT = { hover: true };
+var CONTROL_IDLE = {
+  press: PRESS_IDLE,
+  hovered: false,
+  focused: false,
+  disabled: false
+};
+function stepControl(state, event, caps) {
+  switch (event.type) {
+    case "down":
+    case "up":
+    case "cancel": {
+      const next = stepPress(state.press, event, !state.disabled);
+      return { state: { ...state, press: next.state }, activated: next.activated };
+    }
+    case "leave": {
+      const next = stepPress(state.press, event, !state.disabled);
+      return { state: { ...state, press: next.state, hovered: false }, activated: false };
+    }
+    case "enter":
+      return {
+        state: { ...state, hovered: !state.disabled && stepHover(event, caps.hover) },
+        activated: false
+      };
+    case "focus":
+    case "blur": {
+      const press = event.type === "blur" && state.press.by === "keyboard" ? PRESS_IDLE : state.press;
+      return {
+        state: { ...state, press, focused: !state.disabled && stepFocus(event) },
+        activated: false
+      };
+    }
+    case "disable":
+      return {
+        state: event.disabled ? { press: PRESS_IDLE, hovered: false, focused: false, disabled: true } : { ...state, disabled: false },
+        activated: false
+      };
+  }
+}
+function controlTargets(state) {
+  return {
+    pressed: state.press.by !== null ? 1 : 0,
+    hovered: state.hovered ? 1 : 0,
+    focus: state.focused ? 1 : 0,
+    disabled: state.disabled
+  };
+}
+function stepSpring(s, dt, response, damping, instant = false) {
+  if (instant) {
+    const moved = s.x !== s.target || s.v !== 0;
+    s.x = s.target;
+    s.v = 0;
+    return moved;
+  }
+  const stiffness = (2 * Math.PI / response) ** 2;
+  const friction = 4 * Math.PI * damping / response;
+  const h = 1 / 240;
+  for (let left = Math.min(dt, 0.05); left > 0; left -= h) {
+    const step = Math.min(left, h);
+    s.v += (stiffness * (s.target - s.x) - friction * s.v) * step;
+    s.x += s.v * step;
+  }
+  if (Math.abs(s.target - s.x) < 1e-3 && Math.abs(s.v) < 0.01) {
+    s.x = s.target;
+    s.v = 0;
+    return false;
+  }
+  return true;
+}
+var smoothstep = (e0, e1, x) => {
+  const t = Math.min(Math.max((x - e0) / (e1 - e0), 0), 1);
+  return t * t * (3 - 2 * t);
+};
+var mix = (a, b, t) => a + (b - a) * t;
+var DROP_DIAMETER = 1.1;
+var DROP_LIFT = 0.5;
+var NECK_GAIN = 0.3;
+var NECK_RAMP = 4;
+var CORNER_EASE_START = 0.55;
+var INK_OUT_END = 0.4;
+var INK_IN_START = 0.45;
+var INK_IN_END = 0.95;
+function growthInk(phase) {
+  const a = Math.min(Math.max(phase.shrink, 0), 1);
+  const b = Math.max(phase.grow, 0);
+  return {
+    outgoing: 1 - smoothstep(0, INK_OUT_END, a),
+    incoming: smoothstep(INK_IN_START, INK_IN_END, b)
+  };
+}
+function largerOf(a, b) {
+  return halfMinDp(a.geometry) >= halfMinDp(b.geometry) ? { main: a, other: b } : { main: b, other: a };
+}
+function growthFrame(source, target, anchor, phase) {
+  const dx = target.center.x - source.center.x;
+  const dy = target.center.y - source.center.y;
+  const len = Math.hypot(dx, dy) || 1;
+  const sourceSize = halfMinDp(source.geometry) * 2;
+  const lift = DROP_LIFT * sourceSize;
+  const drop = {
+    x: source.center.x + dx / len * lift,
+    y: source.center.y + dy / len * lift
+  };
+  const a = Math.min(Math.max(phase.shrink, 0), 1);
+  const b = Math.max(phase.grow, 0);
+  const keep = Math.max(1 - b, 0);
+  const d = DROP_DIAMETER * sourceSize;
+  const shrunkGeometry = {
+    width: mix(source.geometry.width, 0.6 * d, a) * keep,
+    height: mix(source.geometry.height, 0.6 * d, a) * keep,
+    cornerRadius: 0
+  };
+  shrunkGeometry.cornerRadius = Math.min(
+    mix(source.geometry.cornerRadius, halfMinDp(shrunkGeometry), a),
+    halfMinDp(shrunkGeometry)
+  );
+  const shrunk = {
+    geometry: shrunkGeometry,
+    center: { x: mix(source.center.x, drop.x, a), y: mix(source.center.y, drop.y, a) }
+  };
+  const seed = d * Math.sqrt(a);
+  const cornerX = Math.sign(anchor.x - source.center.x);
+  const cornerY = Math.sign(anchor.y - source.center.y);
+  const edgeX = mix(drop.x + cornerX * (seed / 2), anchor.x, Math.min(b, 1));
+  const edgeY = mix(drop.y + cornerY * (seed / 2), anchor.y, Math.min(b, 1));
+  const width = mix(seed, target.geometry.width, b);
+  const height = mix(seed, target.geometry.height, b);
+  const grownGeometry = { width, height, cornerRadius: 0 };
+  grownGeometry.cornerRadius = Math.min(
+    mix(halfMinDp(grownGeometry), target.geometry.cornerRadius, smoothstep(CORNER_EASE_START, 1, b)),
+    halfMinDp(grownGeometry)
+  );
+  const grown = {
+    geometry: grownGeometry,
+    center: { x: edgeX - cornerX * (width / 2), y: edgeY - cornerY * (height / 2) }
+  };
+  const { main, other } = largerOf(grown, shrunk);
+  const neck = NECK_GAIN * sourceSize * Math.min(a * NECK_RAMP, 1) * keep;
+  const united = neck > 0.01 && other.geometry.width > 0.5 && other.geometry.height > 0.5;
+  return {
+    body: main,
+    grown,
+    merge: united ? {
+      offsetX: other.center.x - main.center.x,
+      offsetY: other.center.y - main.center.y,
+      width: other.geometry.width,
+      height: other.geometry.height,
+      cornerRadius: other.geometry.cornerRadius,
+      smoothing: neck
+    } : void 0,
+    ink: growthInk(phase)
+  };
+}
+var createGrowthState = () => ({
+  shrink: { x: 0, v: 0, target: 0 },
+  grow: { x: 0, v: 0, target: 0 }
+});
+var growthPhase = (state) => ({
+  shrink: state.shrink.x,
+  grow: state.grow.x
+});
+var DEFAULT_GROWTH_TIMING = {
+  shrinkOpen: 0.38,
+  shrinkClose: 0.3,
+  growOpen: 0.46,
+  growClose: 0.4,
+  growDampingOpen: 0.72
+};
+var GROW_DAMPING_CLOSE = 1;
+var SHRINK_DAMPING = 1;
+var GROW_STARTS_AT = 0.8;
+var SHRINK_RETURNS_AT = 0.12;
+function stepGrowth(state, dt, open, reduceMotion = false, timing = DEFAULT_GROWTH_TIMING) {
+  const { shrink, grow } = state;
+  if (reduceMotion) {
+    shrink.target = open ? 1 : 0;
+    grow.target = open ? 1 : 0;
+  } else if (open) {
+    shrink.target = 1;
+    if (shrink.x > GROW_STARTS_AT) grow.target = 1;
+  } else {
+    grow.target = 0;
+    if (grow.x < SHRINK_RETURNS_AT) shrink.target = 0;
+  }
+  const movedShrink = stepSpring(
+    shrink,
+    dt,
+    open ? timing.shrinkOpen : timing.shrinkClose,
+    SHRINK_DAMPING,
+    reduceMotion
+  );
+  const movedGrow = stepSpring(
+    grow,
+    dt,
+    open ? timing.growOpen : timing.growClose,
+    open ? timing.growDampingOpen : GROW_DAMPING_CLOSE,
+    reduceMotion
+  );
+  return movedShrink || movedGrow;
+}
+
+// src/kit/behavior/visual.ts
+var createControlVisual = () => ({
+  pressed: { x: 0, v: 0, target: 0 },
+  hovered: { x: 0, v: 0, target: 0 },
+  focus: { x: 0, v: 0, target: 0 }
+});
+var PRESS = { response: 0.18, damping: 0.78 };
+var HOVER = { response: 0.22, damping: 1 };
+var FOCUS = { response: 0.16, damping: 1 };
+function stepControlVisual(visual, dt, state, instant = false) {
+  const t = controlTargets(state);
+  visual.pressed.target = t.pressed;
+  visual.hovered.target = t.hovered;
+  visual.focus.target = t.focus;
+  const a = stepSpring(visual.pressed, dt, PRESS.response, PRESS.damping, instant);
+  const b = stepSpring(visual.hovered, dt, HOVER.response, HOVER.damping, instant);
+  const c = stepSpring(visual.focus, dt, FOCUS.response, FOCUS.damping, instant);
+  return a || b || c;
+}
+function visualAtomState(visual, state) {
+  return {
+    pressed: visual.pressed.x,
+    hovered: visual.hovered.x,
+    selected: 0,
+    disabled: state.disabled
+  };
+}
+function settleControlVisual(visual, state) {
+  stepControlVisual(visual, 0, state, true);
+}
+
+// src/kit/response.ts
+var LIFTING = { grow: 0.18, defocus: 1.6 };
+var SINKING = { grow: 0.06, defocus: 1 };
+function pressResponse(kind) {
+  return atomLift(kind) === 1 ? LIFTING : SINKING;
+}
+var CONTROL_SIZES = ["touch", "small", "medium", "large", "xlarge"];
+var MIN_TOUCH_TARGET_DP = 44;
+var MIN_POINTER_TARGET_DP = 24;
+var capsule = (height, paddingX) => ({
+  height,
+  paddingX,
+  icon: Math.round(height / 2),
+  radius: height / 2,
+  shape: "capsule"
+});
+var rounded = (height, paddingX) => ({
+  height,
+  paddingX,
+  icon: Math.round(height / 2),
+  radius: height / 4,
+  shape: "rounded"
+});
+var BUTTON_SIZES = {
+  touch: capsule(44, 20),
+  small: rounded(24, 10),
+  medium: rounded(32, 14),
+  large: capsule(40, 18),
+  xlarge: capsule(48, 22)
+};
+function iconButtonSize(size) {
+  const spec = BUTTON_SIZES[size];
+  return { ...spec, width: spec.height, paddingX: 0 };
+}
+function nestedRadius(outerRadius, inset, minimum = 0) {
+  return concentricRadius(outerRadius, inset, minimum);
+}
+function defaultSize(input) {
+  return input.touch ? "touch" : "medium";
+}
+function hitSlop(bodyDp, minTargetDp) {
+  return bodyDp >= minTargetDp ? 0 : (minTargetDp - bodyDp) / 2;
+}
+function minTarget(input) {
+  return input.touch ? MIN_TOUCH_TARGET_DP : MIN_POINTER_TARGET_DP;
+}
+
+export { A11Y_NONE, ATOM_AT_REST, BUTTON_SIZES, CONTROL_IDLE, CONTROL_SIZES, DEFAULT_GROWTH_TIMING, MIN_POINTER_TARGET_DP, MIN_TOUCH_TARGET_DP, POINTER_INPUT, PRESS_IDLE, TOUCH_INPUT, atomAtRest, atomBody, atomLift, atomMaterial, controlTargets, createControlVisual, createGrowthState, defaultSize, growthFrame, growthInk, growthPhase, hitSlop, iconButtonSize, minTarget, nestedRadius, presentationFor, pressResponse, resolveA11y, sameA11y, settleControlVisual, smoothstep, stepControl, stepControlVisual, stepFocus, stepGrowth, stepHover, stepPress, stepSpring, visualAtomState };
+//# sourceMappingURL=chunk-I3BD3XGC.js.map
+//# sourceMappingURL=chunk-I3BD3XGC.js.map