vireuikit 0.8.0 → 0.9.0

package/dist/chunk-7A3XUTXH.js

@@ -0,0 +1,1314 @@
+import { halfMinDp, concentricRadius, activeMaterial, applyAccessibility, resolveOptics, VIREGLASS_SHEET_MATERIAL } 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;
+}
+
+// src/kit/adaptive/classes.ts
+var WIDTH_CLASSES = ["compact", "medium", "expanded", "large", "xlarge"];
+var HEIGHT_CLASSES = ["compact", "medium", "expanded"];
+var WIDTH_BREAKPOINTS = { medium: 600, expanded: 840, large: 1200, xlarge: 1600 };
+var HEIGHT_BREAKPOINTS = { medium: 480, expanded: 900 };
+function widthClass(width) {
+  if (!(width >= WIDTH_BREAKPOINTS.medium)) return "compact";
+  if (width < WIDTH_BREAKPOINTS.expanded) return "medium";
+  if (width < WIDTH_BREAKPOINTS.large) return "expanded";
+  return width < WIDTH_BREAKPOINTS.xlarge ? "large" : "xlarge";
+}
+function heightClass(height) {
+  if (!(height >= HEIGHT_BREAKPOINTS.medium)) return "compact";
+  return height < HEIGHT_BREAKPOINTS.expanded ? "medium" : "expanded";
+}
+function classifyWindow(size) {
+  return { width: widthClass(size.width), height: heightClass(size.height) };
+}
+function widthAtLeast(value, minimum) {
+  return WIDTH_CLASSES.indexOf(value) >= WIDTH_CLASSES.indexOf(minimum);
+}
+
+// src/kit/geometry.ts
+function intersectRect(a, b) {
+  const x = Math.max(a.x, b.x);
+  const y = Math.max(a.y, b.y);
+  const right = Math.min(a.x + a.width, b.x + b.width);
+  const bottom = Math.min(a.y + a.height, b.y + b.height);
+  return right > x && bottom > y ? { x, y, width: right - x, height: bottom - y } : null;
+}
+function rectContains(outer, inner, tolerance = 0) {
+  return inner.x >= outer.x - tolerance && inner.y >= outer.y - tolerance && inner.x + inner.width <= outer.x + outer.width + tolerance && inner.y + inner.height <= outer.y + outer.height + tolerance;
+}
+
+// src/kit/adaptive/context.ts
+var INPUT_TOUCH = { primary: "coarse", anyCoarse: true, hover: false, keyboard: false };
+var INPUT_POINTER = { primary: "fine", anyCoarse: false, hover: true, keyboard: true };
+var INPUT_MIXED = { primary: "fine", anyCoarse: true, hover: true, keyboard: true };
+var INPUT_TABLET_KEYBOARD = { primary: "coarse", anyCoarse: true, hover: true, keyboard: true };
+var POSTURE_FLAT = { kind: "flat" };
+function adaptiveContext(partial) {
+  return {
+    window: partial.window,
+    input: partial.input ?? INPUT_POINTER,
+    posture: partial.posture ?? POSTURE_FLAT,
+    reduceMotion: partial.reduceMotion ?? false
+  };
+}
+function halfOpen(kind, window, options = {}) {
+  const band = Math.max(options.band ?? 0, 0);
+  const span = kind === "tabletop" ? window.height : window.width;
+  const at = options.at ?? span / 2;
+  const start = at - band / 2;
+  const bounds = kind === "tabletop" ? { x: 0, y: start, width: window.width, height: band } : { x: start, y: 0, width: band, height: window.height };
+  return { kind, fold: { bounds, occluding: options.occluding ?? band > 0 } };
+}
+function windowSegments(ctx) {
+  const { width, height } = ctx.window;
+  const whole = { x: 0, y: 0, width, height };
+  if (ctx.posture.kind === "flat") return [whole];
+  const { bounds, occluding } = ctx.posture.fold;
+  const tabletop = ctx.posture.kind === "tabletop";
+  const span = tabletop ? height : width;
+  const lo = Math.min(Math.max(tabletop ? bounds.y : bounds.x, 0), span);
+  const hi = Math.min(Math.max(lo + (tabletop ? bounds.height : bounds.width), lo), span);
+  const end = occluding ? lo : (lo + hi) / 2;
+  const start = occluding ? hi : (lo + hi) / 2;
+  const parts = tabletop ? [
+    { x: 0, y: 0, width, height: end },
+    { x: 0, y: start, width, height: height - start }
+  ] : [
+    { x: 0, y: 0, width: end, height },
+    { x: start, y: 0, width: width - start, height }
+  ];
+  const kept = parts.filter((r) => r.width > 0 && r.height > 0);
+  return kept.length ? kept : [whole];
+}
+function postureFromSegments(window, segments) {
+  if (segments.length !== 2) return POSTURE_FLAT;
+  const [a, b] = [...segments].sort((p, q) => p.x - q.x || p.y - q.y);
+  const gapX = b.x - (a.x + a.width);
+  if (gapX >= 0 && a.y < b.y + b.height && b.y < a.y + a.height) {
+    return { kind: "book", fold: { bounds: { x: a.x + a.width, y: 0, width: gapX, height: window.height }, occluding: gapX > 0 } };
+  }
+  const [top, bottom] = [...segments].sort((p, q) => p.y - q.y);
+  const gapY = bottom.y - (top.y + top.height);
+  if (gapY >= 0) {
+    return { kind: "tabletop", fold: { bounds: { x: 0, y: top.y + top.height, width: window.width, height: gapY }, occluding: gapY > 0 } };
+  }
+  return POSTURE_FLAT;
+}
+var area = (r) => r ? r.width * r.height : 0;
+function segmentOf(box2, segments) {
+  const cx = box2.x + box2.width / 2;
+  const cy = box2.y + box2.height / 2;
+  const holding = segments.find((s) => cx >= s.x && cx < s.x + s.width && cy >= s.y && cy < s.y + s.height);
+  if (holding) return holding;
+  let best;
+  let most = 0;
+  for (const s of segments) {
+    const overlap = area(intersectRect(s, box2));
+    if (overlap > most) {
+      most = overlap;
+      best = s;
+    }
+  }
+  if (best) return best;
+  let nearest;
+  let distance = Number.POSITIVE_INFINITY;
+  for (const s of segments) {
+    const d = Math.hypot(s.x + s.width / 2 - cx, s.y + s.height / 2 - cy);
+    if (d < distance) {
+      distance = d;
+      nearest = s;
+    }
+  }
+  return nearest;
+}
+function surfaceRegion(ctx, source) {
+  const segments = windowSegments(ctx);
+  if (source) return segmentOf(source, segments) ?? segments[0];
+  return segments.reduce((best, s) => area(s) > area(best) ? s : best, segments[0]);
+}
+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.9;
+var INK_IN_END = 1;
+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 drop2 = {
+    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, drop2.x, a), y: mix(source.center.y, drop2.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(drop2.x + cornerX * (seed / 2), anchor.x, Math.min(b, 1));
+  const edgeY = mix(drop2.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.21,
+  shrinkClose: 0.14,
+  growOpen: 0.38,
+  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/adaptive/form-morph.ts
+var HIDDEN = /* @__PURE__ */ new Set(["hidden", "closed", "none"]);
+function formMorph(change, ctx, options = {}) {
+  const instant = ctx.reduceMotion;
+  if (options.anchorGone) return { ...change, mode: "retract", staysOpen: false, instant };
+  if (change.from === change.to) return { ...change, mode: "none", staysOpen: true, instant };
+  const mode = HIDDEN.has(change.from) ? "appear" : HIDDEN.has(change.to) ? "disappear" : "reshape";
+  return { ...change, mode, staysOpen: mode !== "disappear", instant };
+}
+var FORM_MORPH_TIMING = { response: DEFAULT_GROWTH_TIMING.growOpen, damping: 1 };
+var createFormMorph = () => ({ t: { x: 0, v: 0, target: 0 }, fromInk: 1 });
+function stepFormMorph(state, dt, toward, instant = false) {
+  state.t.target = toward;
+  return stepSpring(state.t, dt, FORM_MORPH_TIMING.response, FORM_MORPH_TIMING.damping, instant);
+}
+var OUT_END = 0.45;
+var IN_START = 0.55;
+function formMorphFrame(from, to, state) {
+  const t = Math.min(Math.max(state.t.x, 0), 1);
+  const mix3 = (a, b) => a + (b - a) * t;
+  return {
+    box: {
+      x: mix3(from.x, to.x),
+      y: mix3(from.y, to.y),
+      width: mix3(from.width, to.width),
+      height: mix3(from.height, to.height),
+      radius: mix3(from.radius, to.radius)
+    },
+    ink: inkAt(state, t),
+    showing: t < 0.5 ? "from" : "to"
+  };
+}
+function inkAt(state, t) {
+  return { outgoing: (state.fromInk ?? 1) * (1 - smoothstep(0, OUT_END, t)), incoming: smoothstep(IN_START, 1, t) };
+}
+function rebaseFormMorph(state) {
+  const t = Math.min(Math.max(state.t.x, 0), 1);
+  const ink = inkAt(state, t);
+  state.fromInk = t < 0.5 ? ink.outgoing : ink.incoming;
+  state.t = { x: 0, v: 0, target: 0 };
+}
+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 };
+}
+var MENU_PADDING = 0.3;
+function menuSize(size) {
+  const spec = BUTTON_SIZES[size];
+  const padding = Math.round(spec.height * MENU_PADDING);
+  return {
+    row: spec.height,
+    padding,
+    itemRadius: spec.radius,
+    radius: spec.radius + padding,
+    icon: spec.icon,
+    labelPad: spec.paddingX
+  };
+}
+function nestedRadius(outerRadius, inset2, minimum = 0) {
+  return concentricRadius(outerRadius, inset2, 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;
+}
+
+// src/kit/adaptive/input.ts
+function sizeTier(input) {
+  return defaultSize({ touch: input.primary === "coarse" });
+}
+function hitTarget(input) {
+  return minTarget({ touch: input.anyCoarse });
+}
+function hoversWith(pointerType) {
+  return pointerType !== "touch";
+}
+
+// src/kit/adaptive/navigation.ts
+var BAR_SLOTS = 5;
+function formFor(ctx, spec) {
+  const { width, height } = classifyWindow(ctx.window);
+  if (ctx.posture.kind === "tabletop") return "bar";
+  if (widthAtLeast(width, "large")) return spec.sidebarCollapsed ? "rail" : "sidebar";
+  if (height === "compact") return "rail";
+  if (width === "compact") return "bar";
+  if (width === "medium" && (spec.panes ?? 1) > 1 && ctx.posture.kind !== "book") return "bar";
+  return "rail";
+}
+function navigationForm(ctx, spec) {
+  const form = formFor(ctx, spec);
+  const width = classifyWindow(ctx.window).width;
+  const large = widthAtLeast(width, "large");
+  const slots = BAR_SLOTS - (spec.search ? 1 : 0);
+  const primary = Math.max(0, Math.min(spec.primary, slots));
+  const secondary = Math.max(0, spec.secondary ?? 0) + Math.max(0, spec.primary - primary);
+  let search = null;
+  if (spec.search) {
+    const shortcut = large || ctx.input.keyboard;
+    if (large) search = { form: "field", place: form === "sidebar" ? "sidebar" : "toolbar", shortcut };
+    else search = form === "bar" ? { form: "button", place: "bar", shortcut } : { form: "item", place: "rail", shortcut };
+  }
+  return {
+    form,
+    edge: form === "bar" ? "bottom" : "leading",
+    primary,
+    secondary,
+    secondaryVisible: form === "sidebar",
+    search,
+    expandable: form !== "rail" ? null : large ? "beside" : width === "expanded" ? "over" : null,
+    collapsible: form === "sidebar"
+  };
+}
+function bottomAccessory(nav, state = {}) {
+  if (nav.form !== "bar") return { placement: "content-bottom", compact: false };
+  return state.barMinimized ? { placement: "in-bar", compact: true } : { placement: "above-bar", compact: false };
+}
+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 clamp2 = (v) => v < 0 ? 0 : v > 1 ? 1 : v;
+  return Math.max(clamp2(state.selected), clamp2(state.pressed), clamp2(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 mix3 = (key) => REST_BODY[key] + (PRESSED_BODY[key] - REST_BODY[key]) * on;
+  let alpha = mix3("alpha");
+  let white = mix3("white");
+  let lift = mix3("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, enabled2) {
+  switch (event.type) {
+    case "down":
+      if (!enabled2 || 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: enabled2 };
+    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
+  };
+}
+
+// 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);
+}
+var MENU_CLOSED = { open: false, active: -1, typed: "", typedAt: Number.NEGATIVE_INFINITY };
+var TYPEAHEAD_SECONDS = 0.5;
+var exists = (items, i) => i >= 0 && i < items.length;
+var enabled = (items, i) => exists(items, i) && !items[i].disabled;
+var reachable = (items, i) => exists(items, i) && (items[i].focusable ?? !items[i].disabled);
+function seek(items, from, step) {
+  const n = items.length;
+  for (let k = 1; k <= n; k += 1) {
+    const i = ((from + step * k) % n + n) % n;
+    if (reachable(items, i)) return i;
+  }
+  return -1;
+}
+var first = (items) => seek(items, -1, 1);
+var last = (items) => seek(items, items.length, -1);
+var toItem = (index) => index < 0 ? { to: "menu" } : { to: "item", index };
+function typeahead(state, items, key, at) {
+  const fresh = at - state.typedAt > TYPEAHEAD_SECONDS;
+  const typed = (fresh ? "" : state.typed) + key.toLowerCase();
+  const repeated = typed.length > 1 && [...typed].every((c) => c === typed[0]);
+  const needle = repeated ? typed[0] : typed;
+  const start = needle.length > 1 ? state.active - 1 : state.active;
+  const n = items.length;
+  for (let k = 1; k <= n; k += 1) {
+    const i = ((start + k) % n + n) % n;
+    if (reachable(items, i) && items[i].label.trim().toLowerCase().startsWith(needle)) {
+      return { state: { ...state, active: i, typed, typedAt: at }, focus: { to: "item", index: i }, chosen: null };
+    }
+  }
+  return { state: { ...state, typed, typedAt: at }, focus: { to: "stay" }, chosen: null };
+}
+function stepMenu(state, event, items) {
+  const stay = { state, focus: { to: "stay" }, chosen: null };
+  if (event.type === "open") {
+    const active = event.focus === "first" ? first(items) : event.focus === "last" ? last(items) : -1;
+    return { state: { ...MENU_CLOSED, open: true, active }, focus: toItem(active), chosen: null };
+  }
+  if (!state.open) return stay;
+  switch (event.type) {
+    case "move": {
+      const active = event.to === "first" ? first(items) : event.to === "last" ? last(items) : seek(items, state.active < 0 && event.to === "previous" ? items.length : state.active, event.to === "next" ? 1 : -1);
+      if (active < 0) return stay;
+      return { state: { ...state, active, typed: "" }, focus: { to: "item", index: active }, chosen: null };
+    }
+    case "point":
+      if (!reachable(items, event.index) || event.index === state.active) return stay;
+      return { state: { ...state, active: event.index, typed: "" }, focus: { to: "item", index: event.index }, chosen: null };
+    case "type":
+      return typeahead(state, items, event.key, event.at);
+    case "choose":
+      if (!enabled(items, event.index)) return stay;
+      return { state: MENU_CLOSED, focus: { to: "trigger" }, chosen: event.index };
+    case "dismiss":
+      return { state: MENU_CLOSED, focus: event.reason === "outside" ? { to: "none" } : { to: "trigger" }, chosen: null };
+  }
+}
+var MENU_CORNERS = {
+  "top-left": { x: -1, y: -1 },
+  "top-right": { x: 1, y: -1 },
+  "bottom-left": { x: -1, y: 1 },
+  "bottom-right": { x: 1, y: 1 }
+};
+function menuCorner(trigger, region) {
+  const x0 = region.x ?? 0;
+  const y0 = region.y ?? 0;
+  return {
+    x: trigger.x + trigger.width / 2 <= x0 + region.width / 2 ? -1 : 1,
+    y: trigger.y + trigger.height / 2 <= y0 + region.height / 2 ? -1 : 1
+  };
+}
+function along(start, length, size, side) {
+  return side < 0 ? start : start + length - size;
+}
+function fits(at, size, lo, hi, margin) {
+  return at >= lo + margin && at + size <= hi - margin;
+}
+var clamp = (v, lo, hi) => Math.min(Math.max(v, lo), Math.max(lo, hi));
+function menuPlacement(trigger, menu, region, options = {}) {
+  const margin = options.margin ?? 8;
+  const x0 = region.x ?? 0;
+  const y0 = region.y ?? 0;
+  const x1 = x0 + region.width;
+  const y1 = y0 + region.height;
+  const width = Math.max(0, Math.min(menu.width, region.width - 2 * margin));
+  const height = Math.max(0, Math.min(menu.height, region.height - 2 * margin));
+  const corner = { ...options.corner ?? menuCorner(trigger, region) };
+  let x = along(trigger.x, trigger.width, width, corner.x);
+  let y = along(trigger.y, trigger.height, height, corner.y);
+  if (!options.corner) {
+    const fx = along(trigger.x, trigger.width, width, corner.x === -1 ? 1 : -1);
+    if (!fits(x, width, x0, x1, margin) && fits(fx, width, x0, x1, margin)) {
+      corner.x = corner.x === -1 ? 1 : -1;
+      x = fx;
+    }
+    const fy = along(trigger.y, trigger.height, height, corner.y === -1 ? 1 : -1);
+    if (!fits(y, height, y0, y1, margin) && fits(fy, height, y0, y1, margin)) {
+      corner.y = corner.y === -1 ? 1 : -1;
+      y = fy;
+    }
+  }
+  x = clamp(x, x0 + margin, x1 - margin - width);
+  y = clamp(y, y0 + margin, y1 - margin - height);
+  const rect = { x, y, width, height };
+  return {
+    rect,
+    corner,
+    anchor: { x: corner.x < 0 ? x : x + width, y: corner.y < 0 ? y : y + height }
+  };
+}
+var center = (r) => ({ x: r.x + r.width / 2, y: r.y + r.height / 2 });
+function menuActivity(phase) {
+  const shrink = Math.min(Math.max(phase.shrink, 0), 1);
+  const grow = Math.min(Math.max(phase.grow, 0), 1);
+  return shrink * (1 - grow);
+}
+function menuSurfaceFrame(trigger, menu, anchor, phase, bounds) {
+  const frame = growthFrame(
+    { geometry: { width: trigger.width, height: trigger.height, cornerRadius: trigger.radius }, center: center(trigger) },
+    { geometry: { width: menu.width, height: menu.height, cornerRadius: menu.radius }, center: center(menu) },
+    anchor,
+    phase
+  );
+  const { geometry, center: c } = frame.body;
+  let box2 = {
+    x: c.x - geometry.width / 2,
+    y: c.y - geometry.height / 2,
+    width: geometry.width,
+    height: geometry.height,
+    radius: geometry.cornerRadius
+  };
+  let morph = frame.merge;
+  const held = bounds ? intersectRect(box2, bounds) : null;
+  if (held && (held.width < box2.width || held.height < box2.height)) {
+    const was = center(box2);
+    const now = center(held);
+    box2 = { ...held, radius: Math.min(box2.radius, held.width / 2, held.height / 2) };
+    if (morph) morph = { ...morph, offsetX: morph.offsetX + was.x - now.x, offsetY: morph.offsetY + was.y - now.y };
+  }
+  return {
+    box: box2,
+    morph,
+    content: { x: menu.x - box2.x, y: menu.y - box2.y },
+    ink: frame.ink,
+    activity: menuActivity(phase)
+  };
+}
+function menuGlass(base) {
+  return { ...base, roughness: Math.max(base.roughness, VIREGLASS_SHEET_MATERIAL.roughness) };
+}
+function menuMaterial(base, activity) {
+  return atomMaterial(menuGlass(base), "menu", { ...ATOM_AT_REST, pressed: activity });
+}
+var MENU_DROP_BODY = { alpha: 0.9, white: 0.1, lift: 0.2 };
+function menuBody(base, activity, frost = false) {
+  const rest = atomBody(base, ATOM_AT_REST, frost);
+  if (frost) return rest;
+  const k = Math.min(Math.max(activity, 0), 1);
+  const mix3 = (key) => rest[key] + (MENU_DROP_BODY[key] - rest[key]) * k;
+  return { alpha: mix3("alpha"), white: mix3("white"), lift: mix3("lift") };
+}
+var MENU_ITEM_FILL = { active: 0.1, pressed: 0.18 };
+function menuItemFill(state) {
+  if (state.disabled) return 0;
+  if (state.pressed) return MENU_ITEM_FILL.pressed;
+  return state.active ? MENU_ITEM_FILL.active : 0;
+}
+
+// src/kit/nav/layout.ts
+var NAV_SIZES = {
+  bar: { height: 56, item: 74, minItem: 44, inset: 3, margin: 16, searchGap: 8, minimized: 44 },
+  rail: { width: 80, item: 56, gap: 4, padding: 8, margin: 8, head: 48 },
+  sidebar: { width: 280, row: { touch: 44, pointer: 36 }, padding: 8, margin: 8, head: 48, separator: 12 },
+  accessory: { height: 48, gap: 8, inline: 44, content: 56, margin: 8 },
+  lens: { inflate: 6 },
+  toggle: 44
+};
+var box = (x, y, width, height, radius) => ({ x, y, width, height, radius });
+function barLayout(input, items, minimized) {
+  const { bar, accessory } = NAV_SIZES;
+  const { width, height } = input.window;
+  const bottom = Math.max(input.bottomInset ?? 0, bar.margin);
+  const hasSearch = input.search?.form === "button";
+  const placement = input.accessory ? bottomAccessory({ form: "bar" }, { barMinimized: minimized }).placement : null;
+  const selected = input.selected >= 0 && input.selected < items ? input.selected : -1;
+  if (minimized) {
+    const centre = height - bottom - bar.height / 2;
+    const d = bar.minimized;
+    const body2 = box(bar.margin, centre - d / 2, d, d, d / 2);
+    const search2 = hasSearch ? box(width - bar.margin - d, body2.y, d, d, d / 2) : null;
+    let acc2 = null;
+    if (placement) {
+      const x2 = body2.x + d + accessory.gap;
+      const right = search2 ? search2.x - accessory.gap : width - bar.margin;
+      acc2 = box(x2, body2.y, Math.max(0, right - x2), accessory.inline, accessory.inline / 2);
+    }
+    return {
+      form: "bar",
+      minimized: true,
+      body: body2,
+      items: Array.from({ length: items }, () => ({ ...body2 })),
+      pill: selected >= 0 ? { ...body2 } : null,
+      search: search2,
+      accessory: acc2,
+      toggle: null,
+      accessoryPlacement: placement,
+      insets: { bottom: height - body2.y, start: 0 }
+    };
+  }
+  const searchBlock = hasSearch ? bar.height + bar.searchGap : 0;
+  const fit = items > 0 ? (width - 2 * bar.margin - searchBlock - 2 * bar.inset) / items : bar.item;
+  const itemWidth = Math.max(bar.minItem, Math.min(bar.item, fit));
+  const bodyWidth = items * itemWidth + 2 * bar.inset;
+  const x = Math.max(bar.margin, (width - bodyWidth - searchBlock) / 2);
+  const body = box(x, height - bottom - bar.height, bodyWidth, bar.height, bar.height / 2);
+  const cellHeight = bar.height - 2 * bar.inset;
+  const cells = Array.from(
+    { length: items },
+    (_, i) => box(x + bar.inset + i * itemWidth, body.y + bar.inset, itemWidth, cellHeight, cellHeight / 2)
+  );
+  const search = hasSearch ? box(x + bodyWidth + bar.searchGap, body.y, bar.height, bar.height, bar.height / 2) : null;
+  let acc = null;
+  if (placement) {
+    acc = box(body.x, body.y - accessory.gap - accessory.height, bodyWidth + searchBlock, accessory.height, accessory.height / 2);
+  }
+  return {
+    form: "bar",
+    minimized: false,
+    body,
+    items: cells,
+    pill: selected >= 0 ? { ...cells[selected] } : null,
+    search,
+    accessory: acc,
+    toggle: null,
+    accessoryPlacement: placement,
+    insets: { bottom: height - body.y + (acc ? accessory.height + accessory.gap : 0), start: 0 }
+  };
+}
+function contentAccessory(input, start) {
+  const { accessory } = NAV_SIZES;
+  const base = input.bottomInset ?? 0;
+  if (!input.accessory) return { box: null, bottom: base };
+  const bottom = Math.max(base, accessory.margin);
+  const width = Math.max(0, input.window.width - start - accessory.margin);
+  const acc = box(start, input.window.height - bottom - accessory.content, width, accessory.content, accessory.content / 2);
+  return { box: acc, bottom: bottom + accessory.content };
+}
+function headToggle(body, padding, head, dx) {
+  const d = NAV_SIZES.toggle;
+  return box(body.x + dx, body.y + padding + (head - d) / 2, d, d, d / 2);
+}
+function inset(b, d) {
+  return box(b.x + d, b.y + d, b.width - 2 * d, b.height - 2 * d, (Math.min(b.width, b.height) - 2 * d) / 2);
+}
+function railLayout(input, items) {
+  const { rail, bar } = NAV_SIZES;
+  const hasSearch = input.search?.form === "item";
+  const n = items + (hasSearch ? 1 : 0);
+  const head = input.toggle ? rail.head : 0;
+  const natural = rail.padding * 2 + head + n * rail.item + Math.max(n - 1, 0) * rail.gap;
+  const height = Math.min(natural, Math.max(input.window.height - 2 * rail.margin, 0));
+  const body = box(rail.margin, rail.margin, rail.width, height, 28);
+  const cell = (i) => box(body.x + rail.padding, body.y + rail.padding + head + i * (rail.item + rail.gap), rail.width - 2 * rail.padding, rail.item, 24);
+  const cells = Array.from({ length: items }, (_, i) => cell(i));
+  const selected = input.selected >= 0 && input.selected < items ? input.selected : -1;
+  const start = body.x + body.width + rail.margin;
+  const acc = contentAccessory(input, start);
+  return {
+    form: "rail",
+    minimized: false,
+    body,
+    items: cells,
+    pill: selected >= 0 ? inset(cells[selected], bar.inset) : null,
+    search: hasSearch ? cell(items) : null,
+    accessory: acc.box,
+    toggle: input.toggle ? headToggle(body, rail.padding, rail.head, (rail.width - NAV_SIZES.toggle) / 2) : null,
+    accessoryPlacement: acc.box ? "content-bottom" : null,
+    insets: { bottom: acc.bottom, start }
+  };
+}
+function sidebarLayout(input, items, secondary) {
+  const { sidebar } = NAV_SIZES;
+  const row = sidebar.row[input.tier];
+  const body = box(sidebar.margin, sidebar.margin, sidebar.width, input.window.height - 2 * sidebar.margin, 24);
+  const rowWidth = sidebar.width - 2 * sidebar.padding;
+  const rowAt = (y2) => box(body.x + sidebar.padding, y2, rowWidth, row, row / 2);
+  let y = body.y + sidebar.padding + (input.toggle ? sidebar.head : 0);
+  let search = null;
+  if (input.search?.form === "field") {
+    search = rowAt(y);
+    y += row;
+  }
+  const cells = [];
+  for (let i = 0; i < items; i += 1, y += row) cells.push(rowAt(y));
+  if (secondary > 0) y += sidebar.separator;
+  for (let i = 0; i < secondary; i += 1, y += row) cells.push(rowAt(y));
+  const selected = input.selected >= 0 && input.selected < cells.length ? input.selected : -1;
+  const start = body.x + body.width + sidebar.margin;
+  const acc = contentAccessory(input, start);
+  return {
+    form: "sidebar",
+    minimized: false,
+    body,
+    items: cells,
+    pill: selected >= 0 ? { ...cells[selected] } : null,
+    search,
+    accessory: acc.box,
+    toggle: input.toggle ? headToggle(body, sidebar.padding, sidebar.head, sidebar.width - sidebar.padding - NAV_SIZES.toggle) : null,
+    accessoryPlacement: acc.box ? "content-bottom" : null,
+    insets: { bottom: acc.bottom, start }
+  };
+}
+function navLayout(input) {
+  const items = Math.max(0, Math.floor(input.items));
+  const secondary = Math.max(0, Math.floor(input.secondary));
+  if (input.form === "bar") return barLayout(input, items, !!input.minimized);
+  return input.form === "rail" ? railLayout(input, items) : sidebarLayout(input, items, secondary);
+}
+
+// src/kit/nav/drag.ts
+var MAX_STRETCH = 0.25;
+var SATURATION_SPEED = 1500;
+var STRETCH_TAU = 0.05;
+var OVERHANG = 4;
+var LAND = { response: 0.2, damping: 0.8 };
+var LIFT = { response: 0.2, damping: 1 };
+var createNavDrag = () => ({
+  active: false,
+  x: { x: 0, v: 0, target: 0 },
+  lift: { x: 0, v: 0, target: 0 },
+  stretch: 0,
+  index: 0,
+  lastX: 0
+});
+var draggable = (layout) => layout.form === "bar" && !layout.minimized && layout.items.length > 0;
+function lensSize(layout) {
+  const cell = layout.items[0];
+  const pad = 2 * NAV_SIZES.lens.inflate;
+  return { width: cell.width + pad, height: cell.height + pad };
+}
+function clampCentre(layout, x) {
+  const half = lensSize(layout).width / 2;
+  const { body } = layout;
+  return Math.min(Math.max(x, body.x + half - OVERHANG), body.x + body.width - half + OVERHANG);
+}
+function indexAt(layout, x) {
+  const first2 = layout.items[0];
+  const i = Math.floor((x - first2.x) / first2.width);
+  return Math.min(Math.max(i, 0), layout.items.length - 1);
+}
+var centreOf = (layout, index) => layout.items[index].x + layout.items[index].width / 2;
+function drop(state) {
+  state.active = false;
+  state.lift.x = 0;
+  state.lift.v = 0;
+  state.lift.target = 0;
+}
+function settleTowards(state, layout, index) {
+  state.active = false;
+  state.index = index;
+  state.x.target = centreOf(layout, index);
+  state.lift.target = 0;
+}
+function pressNavDrag(state, layout, pointerX) {
+  if (!draggable(layout)) return;
+  const x = clampCentre(layout, pointerX);
+  state.active = true;
+  state.x.x = x;
+  state.x.v = 0;
+  state.x.target = x;
+  state.lift.target = 1;
+  state.stretch = 0;
+  state.lastX = pointerX;
+  state.index = indexAt(layout, x);
+}
+function moveNavDrag(state, layout, pointerX, dt) {
+  if (!state.active || !draggable(layout)) return;
+  const x = clampCentre(layout, pointerX);
+  state.x.x = x;
+  state.x.v = 0;
+  state.x.target = x;
+  const speed = dt > 0 ? Math.abs(pointerX - state.lastX) / dt : 0;
+  const goal = MAX_STRETCH * Math.min(speed / SATURATION_SPEED, 1);
+  state.stretch += (goal - state.stretch) * (dt > 0 ? 1 - Math.exp(-dt / STRETCH_TAU) : 1);
+  state.lastX = pointerX;
+  state.index = indexAt(layout, x);
+}
+function releaseNavDrag(state, layout) {
+  if (!draggable(layout)) {
+    drop(state);
+    return state.index;
+  }
+  const index = indexAt(layout, state.x.x);
+  settleTowards(state, layout, index);
+  return index;
+}
+function cancelNavDrag(state, layout, selected) {
+  if (!draggable(layout)) {
+    drop(state);
+    return;
+  }
+  const index = selected >= 0 && selected < layout.items.length ? selected : indexAt(layout, state.x.x);
+  settleTowards(state, layout, index);
+}
+function stepNavDrag(state, dt, reduceMotion = false) {
+  let moving = state.active;
+  if (state.stretch > 0) {
+    state.stretch *= Math.exp(-Math.max(dt, 0) / STRETCH_TAU);
+    if (reduceMotion || state.stretch < 1e-3) state.stretch = 0;
+    else moving = true;
+  }
+  if (!state.active && stepSpring(state.x, dt, LAND.response, LAND.damping, reduceMotion)) moving = true;
+  if (stepSpring(state.lift, dt, LIFT.response, LIFT.damping, reduceMotion)) moving = true;
+  return moving;
+}
+function navDragFrame(state, layout) {
+  if (!draggable(layout)) return null;
+  const lift = Math.min(Math.max(state.lift.x, 0), 1);
+  if (!state.active && lift === 0 && state.x.x === state.x.target) return null;
+  const size = lensSize(layout);
+  const width = size.width * (1 + state.stretch);
+  const height = size.height * (1 - state.stretch / 2);
+  const cy = layout.body.y + layout.body.height / 2;
+  return {
+    lens: { x: state.x.x - width / 2, y: cy - height / 2, width, height, radius: height / 2 },
+    lift,
+    hover: indexAt(layout, state.x.x)
+  };
+}
+
+// src/kit/nav/form.ts
+var SEARCH = {
+  bar: { form: "button", place: "bar" },
+  rail: { form: "item", place: "rail" },
+  sidebar: { form: "field", place: "sidebar" }
+};
+function fixedNavigationForm(nav, form) {
+  if (nav.form === form) return nav;
+  return {
+    ...nav,
+    form,
+    edge: form === "bar" ? "bottom" : "leading",
+    secondaryVisible: form === "sidebar",
+    search: nav.search ? { ...nav.search, ...SEARCH[form] } : null,
+    expandable: form === "rail" ? nav.expandable : null,
+    collapsible: form === "sidebar"
+  };
+}
+
+// src/kit/nav/minimize.ts
+var MINIMIZE_THRESHOLD = 24;
+var MINIMIZE_JITTER = 4;
+var createMinimize = (scrollTop = 0) => ({ minimized: false, run: 0, last: scrollTop });
+function stepMinimize(state, scrollTop) {
+  const delta = scrollTop - state.last;
+  state.last = scrollTop;
+  if (scrollTop <= 0) {
+    state.minimized = false;
+    state.run = 0;
+    return false;
+  }
+  if (delta === 0) return state.minimized;
+  const along2 = Math.sign(delta) === Math.sign(state.run) || Math.abs(delta) < MINIMIZE_JITTER;
+  state.run = along2 ? state.run + delta : delta;
+  if (state.run >= MINIMIZE_THRESHOLD) state.minimized = true;
+  else if (state.run <= -MINIMIZE_THRESHOLD) state.minimized = false;
+  return state.minimized;
+}
+var clampScrollTop = (scrollTop, scrollHeight, clientHeight) => Math.min(Math.max(scrollTop, 0), Math.max(scrollHeight - clientHeight, 0));
+function expandMinimize(state) {
+  state.minimized = false;
+  state.run = 0;
+}
+
+// src/kit/nav/morph.ts
+var NAV_MORPH_TIMING = { response: 1.06, damping: 1 };
+var NAV_MINIMIZE_TIMING = FORM_MORPH_TIMING;
+var LIFT_END = 0.12;
+var CONTRACT = [0.08, 0.38];
+var TRAVEL = [0.36, 0.56];
+var GROW = [0.52, 0.86];
+var SETTLE_START = 0.82;
+var INK_OUT = [0.08, 0.28];
+var INK_IN = [0.62, 0.86];
+var SWAP_AT = 0.46;
+var SMOOTHING = 24;
+var SEED = 8;
+var STAND_IN = 44;
+var clamp01 = (x) => Math.min(Math.max(x, 0), 1);
+var mix2 = (a, b, t) => a + (b - a) * t;
+var mixBox = (a, b, t) => ({
+  x: mix2(a.x, b.x, t),
+  y: mix2(a.y, b.y, t),
+  width: mix2(a.width, b.width, t),
+  height: mix2(a.height, b.height, t),
+  radius: mix2(a.radius, b.radius, t)
+});
+var inflate = (b, d) => ({
+  x: b.x - d,
+  y: b.y - d,
+  width: b.width + 2 * d,
+  height: b.height + 2 * d,
+  radius: b.radius + d
+});
+var centred = (cx, cy, size) => ({ x: cx - size / 2, y: cy - size / 2, width: size, height: size, radius: size / 2 });
+var trailingEnd = (body, size) => centred(body.x + body.width - body.height / 2, body.y + body.height / 2, size);
+var pillOrStandIn = (layout) => layout.pill ?? centred(layout.body.x + layout.body.width / 2, layout.body.y + layout.body.height / 2, STAND_IN);
+var separateSearch = (layout) => layout.form === "bar" ? layout.search : null;
+function restFrame(layout, side) {
+  const search = separateSearch(layout);
+  return {
+    phase: "rest",
+    body: layout.body,
+    second: search ? { box: search, smoothing: 0 } : null,
+    lens: null,
+    ink: side === "from" ? { outgoing: 1, incoming: 0 } : { outgoing: 0, incoming: 1 },
+    showing: side
+  };
+}
+var layoutOrigin = (layout) => {
+  const search = separateSearch(layout);
+  return {
+    body: layout.body,
+    second: search ? { box: search, smoothing: 0 } : null,
+    lens: { box: pillOrStandIn(layout), lift: 0 },
+    ink: 1,
+    lead: 0,
+    hold: null
+  };
+};
+var frameOrigin = (frame) => ({
+  body: frame.body,
+  second: frame.second,
+  lens: frame.lens ?? { box: centred(frame.body.x + frame.body.width / 2, frame.body.y + frame.body.height / 2, STAND_IN), lift: 0 },
+  ink: Math.max(frame.ink.outgoing, frame.ink.incoming),
+  lead: CONTRACT[0],
+  hold: null
+});
+function phaseAt(tau) {
+  if (tau < CONTRACT[0]) return "lift";
+  if (tau < TRAVEL[0]) return "contract";
+  if (tau < GROW[0]) return "travel";
+  return tau < SETTLE_START ? "grow" : "settle";
+}
+function lensFrame(o, to, t) {
+  const tau = o.lead + (1 - o.lead) * t;
+  const u = smoothstep(o.lead, LIFT_END, tau);
+  const base = inflate(o.lens.box, NAV_SIZES.lens.inflate * (1 - o.lens.lift) * u);
+  const lift = mix2(o.lens.lift, 1, u);
+  const toPill = pillOrStandIn(to);
+  const k = smoothstep(TRAVEL[0], TRAVEL[1], tau);
+  const kk = o.hold ? clamp01((k - o.hold.k0) / (1 - o.hold.k0)) : k;
+  const travelling = mixBox(o.hold?.box ?? base, inflate(toPill, NAV_SIZES.lens.inflate), kk);
+  const c = smoothstep(CONTRACT[0], CONTRACT[1], tau);
+  const g = smoothstep(GROW[0], GROW[1], tau);
+  const s = smoothstep(SETTLE_START, 1, tau);
+  const contracted = mixBox(o.body, travelling, c);
+  const body = mixBox(contracted, to.body, g);
+  let second = null;
+  const budding = separateSearch(to);
+  if (o.second && c < 1) {
+    second = {
+      box: mixBox(o.second.box, trailingEnd(contracted, 0), c),
+      smoothing: mix2(o.second.smoothing, SMOOTHING, c)
+    };
+  } else if (budding && g > 0) {
+    second = { box: mixBox(trailingEnd(body, SEED), budding, g), smoothing: SMOOTHING * (1 - g) };
+  }
+  return {
+    phase: phaseAt(tau),
+    body,
+    second,
+    lens: { box: mixBox(travelling, toPill, s), lift: lift * (1 - s) },
+    ink: {
+      outgoing: o.ink * (1 - smoothstep(INK_OUT[0], INK_OUT[1], tau)),
+      incoming: smoothstep(INK_IN[0], INK_IN[1], tau)
+    },
+    showing: tau < SWAP_AT ? "from" : "to"
+  };
+}
+function contractFrame(o, to, t) {
+  const body = mixBox(o.body, to.body, t);
+  const target = separateSearch(to);
+  let second = null;
+  if (o.second && target) {
+    second = { box: mixBox(o.second.box, target, t), smoothing: mix2(o.second.smoothing, 0, t) };
+  } else if (o.second) {
+    second = { box: mixBox(o.second.box, trailingEnd(body, 0), t), smoothing: mix2(o.second.smoothing, SMOOTHING, t) };
+  } else if (target) {
+    second = { box: mixBox(trailingEnd(body, SEED), target, t), smoothing: SMOOTHING * (1 - t) };
+  }
+  return {
+    phase: "contract",
+    body,
+    second,
+    lens: null,
+    ink: { outgoing: o.ink * (1 - smoothstep(0, 0.45, t)), incoming: smoothstep(0.55, 1, t) },
+    showing: t < 0.5 ? "from" : "to"
+  };
+}
+var frameFrom = (o, to, t, via) => via === "lens" ? lensFrame(o, to, t) : contractFrame(o, to, t);
+function navMorphFrame(from, to, t, via = "lens") {
+  if (t <= 0) return restFrame(from, "from");
+  if (t >= 1) return restFrame(to, "to");
+  return frameFrom(layoutOrigin(from), to, t, via);
+}
+var createNavMorph = (at) => ({
+  t: { x: 0, v: 0, target: 0 },
+  from: at,
+  to: at,
+  via: "lens",
+  pivot: null,
+  pivotAt: 0
+});
+var sameForm = (a, b) => a.form === b.form && a.minimized === b.minimized;
+var atRest = (s) => s.t.v === 0 && s.t.x === s.t.target && (s.t.x === 0 || s.t.x === 1);
+function currentNavFrame(state) {
+  const x = clamp01(state.t.x);
+  if (x >= 1) return restFrame(state.to, "to");
+  const { pivot } = state;
+  if (!pivot) return navMorphFrame(state.from, state.to, x, state.via);
+  if (state.pivotAt > 0 && pivot.lens) {
+    const origin = layoutOrigin(state.from);
+    origin.hold = { box: pivot.lens.box, k0: smoothstep(TRAVEL[0], TRAVEL[1], state.pivotAt) };
+    return lensFrame(origin, state.to, x);
+  }
+  return frameFrom(frameOrigin(pivot), state.to, x, state.via);
+}
+function aimNavMorph(state, next, via = "lens") {
+  const { t } = state;
+  if (atRest(state)) {
+    const current = t.x >= 1 ? state.to : state.from;
+    if (sameForm(current, next)) {
+      if (t.x >= 1) state.to = next;
+      else state.from = next;
+      state.pivot = null;
+      return;
+    }
+    state.from = current;
+    state.to = next;
+    state.via = via;
+    state.pivot = null;
+    state.pivotAt = 0;
+    t.x = 0;
+    t.v = 0;
+    t.target = 1;
+    return;
+  }
+  if (!state.pivot) {
+    if (sameForm(next, state.from)) {
+      state.from = next;
+      t.target = 0;
+      return;
+    }
+    if (sameForm(next, state.to)) {
+      state.to = next;
+      t.target = 1;
+      return;
+    }
+    const x = clamp01(t.x);
+    if (via === "lens" && state.via === "lens" && x < GROW[0]) {
+      if (x >= TRAVEL[0]) {
+        state.pivot = currentNavFrame(state);
+        state.pivotAt = x;
+      }
+      state.to = next;
+      t.target = 1;
+      return;
+    }
+  } else if (sameForm(next, state.to)) {
+    state.to = next;
+    t.target = 1;
+    return;
+  }
+  const frozen = currentNavFrame(state);
+  if (frozen.showing === "to") state.from = state.to;
+  state.pivot = frozen;
+  state.pivotAt = 0;
+  state.to = next;
+  state.via = via;
+  t.x = 0;
+  t.v = 0;
+  t.target = 1;
+}
+function stepNavMorph(state, dt, reduceMotion = false) {
+  const timing = state.via === "lens" ? NAV_MORPH_TIMING : NAV_MINIMIZE_TIMING;
+  const moved = stepSpring(state.t, dt, timing.response, timing.damping, reduceMotion);
+  if (!moved && state.t.x >= 1) {
+    state.pivot = null;
+    state.pivotAt = 0;
+  }
+  return moved;
+}
+
+// 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;
+}
+
+export { A11Y_NONE, ATOM_AT_REST, BAR_SLOTS, BUTTON_SIZES, CONTROL_IDLE, CONTROL_SIZES, DEFAULT_GROWTH_TIMING, FORM_MORPH_TIMING, HEIGHT_BREAKPOINTS, HEIGHT_CLASSES, INPUT_MIXED, INPUT_POINTER, INPUT_TABLET_KEYBOARD, INPUT_TOUCH, MENU_CLOSED, MENU_CORNERS, MENU_DROP_BODY, MENU_ITEM_FILL, MINIMIZE_JITTER, MINIMIZE_THRESHOLD, MIN_POINTER_TARGET_DP, MIN_TOUCH_TARGET_DP, NAV_MINIMIZE_TIMING, NAV_MORPH_TIMING, NAV_SIZES, POINTER_INPUT, POSTURE_FLAT, PRESS_IDLE, TOUCH_INPUT, TYPEAHEAD_SECONDS, WIDTH_BREAKPOINTS, WIDTH_CLASSES, adaptiveContext, aimNavMorph, atomAtRest, atomBody, atomLift, atomMaterial, bottomAccessory, cancelNavDrag, clampScrollTop, classifyWindow, controlTargets, createControlVisual, createFormMorph, createGrowthState, createMinimize, createNavDrag, createNavMorph, currentNavFrame, defaultSize, expandMinimize, fixedNavigationForm, formMorph, formMorphFrame, growthFrame, growthInk, growthPhase, halfOpen, heightClass, hitSlop, hitTarget, hoversWith, iconButtonSize, intersectRect, menuActivity, menuBody, menuCorner, menuGlass, menuItemFill, menuMaterial, menuPlacement, menuSize, menuSurfaceFrame, minTarget, moveNavDrag, navDragFrame, navLayout, navMorphFrame, navigationForm, nestedRadius, postureFromSegments, presentationFor, pressNavDrag, pressResponse, rebaseFormMorph, rectContains, releaseNavDrag, resolveA11y, sameA11y, segmentOf, settleControlVisual, sizeTier, smoothstep, stepControl, stepControlVisual, stepFocus, stepFormMorph, stepGrowth, stepHover, stepMenu, stepMinimize, stepNavDrag, stepNavMorph, stepPress, stepSpring, surfaceRegion, visualAtomState, widthAtLeast, widthClass, windowSegments };
+//# sourceMappingURL=chunk-7A3XUTXH.js.map
+//# sourceMappingURL=chunk-7A3XUTXH.js.map