Delete workspaceNew

"use client";import * as React from "react";import { Trash2 } from "lucide-react";import { Boo, type BooMode } from "./boo-ghost";import { HoldToConfirm, type HoldStatus } from "./hold-to-confirm";import { Input } from "./input";import { StatusButton, type ActionStatus } from "./status-button";import { TextMorph } from "./text-morph";import { EASE_OUT, useInteractionReducedMotion } from "./ui-interaction-motion";/* ───────────────────────────────────────────────────────── * DELETE WORKSPACE: its ghost climbs out as you type its name * *   safe     the workspace's tile sits on the lit stage *   type     each letter of its name you type brings Boo, its *            ghost, further up out of the tile while the tile *            loses its colour; a wrong letter and he shivers *            and sinks back to where the name still matches *   hold     with the name right, Delete arms; holding it, Boo *            waves and drifts up out of the stage over the hold, *            and drops back if you let go *   deleted  the tile is an empty dashed outline, and a moment *            later Boo peeks up over the edge; Restore (for *            graceDays) brings him diving back into his tile * * onDelete and onRestore are yours; nothing happens until the * whole name is typed and the hold completes. * ───────────────────────────────────────────────────────── */export interface DeleteWorkspaceProps {  /** The name to type, exactly. */  name: string;  /** Its logo; initials on `color` without one. */  avatar?: string;  color?: string;  /** What's being deleted: workspace, project, account… */  kind?: string;  /** What goes with it, one short line each ("12 projects and their history"). */  consequences?: string[];  /** Delete it; throw to keep it and offer another hold. */  onDelete: () => Promise<unknown>;  /** Shows Restore after the delete. */  onRestore?: () => Promise<unknown>;  /** Days it can be restored in, for the line after the delete. */  graceDays?: number;  /** How long Delete has to be held, in ms. */  holdMs?: number;  className?: string;}const mix = (color: string, amount: number, into = "transparent") => `color-mix(in oklab, ${color} ${amount}%, ${into})`;const PF = "var(--primary-foreground)";const CARD: React.CSSProperties = {  backgroundImage: `linear-gradient(180deg, var(--card), ${mix("var(--card)", 95, "var(--foreground)")})`,  boxShadow: `0 0 0 1px var(--border), inset 0 1px 0 ${mix("var(--background)", 85)}`,};/* The one lit surface, with a faint spotlight on the tile: it's the thing everyone's looking at. */const STAGE: React.CSSProperties = {  backgroundColor: "var(--primary)",  backgroundImage: [    `radial-gradient(34% 46% at 50% 66%, ${mix(PF, 22)} 0%, transparent 100%)`,    `radial-gradient(120% 90% at 0% 0%, ${mix(PF, 14)} 0%, transparent 55%)`,    `linear-gradient(175deg, transparent 40%, ${mix("black", 24)} 100%)`,  ].join(", "),  boxShadow: `inset 0 1px 0 ${mix(PF, 36)}, inset 0 0 0 1px ${mix(PF, 12)}`,};const DANGER: React.CSSProperties = { background: "var(--color-red-600, oklch(0.58 0.22 27))", borderColor: "transparent", color: "white" };/* not armed yet: a quiet grey, not a faded version of the main colour */const UNARMED: React.CSSProperties = { background: mix("var(--foreground)", 7), borderColor: "transparent", color: "var(--muted-foreground)" };const initials = (name: string) =>  name    .split(/\s+/)    .filter(Boolean)    .slice(0, 2)    .map((w) => w[0]!.toUpperCase())    .join("");export function DeleteWorkspace({  name,  avatar,  color = "var(--chart-1, var(--primary))",  kind = "workspace",  consequences,  onDelete,  onRestore,  graceDays = 30,  holdMs = 1500,  className = "",}: DeleteWorkspaceProps) {  const reduced = useInteractionReducedMotion();  const baseId = React.useId();  const boo = React.useRef<{ shiver: () => void }>(null);  const [typed, setTyped] = React.useState("");  const [hold, setHold] = React.useState<HoldStatus>("idle");  const [deleted, setDeleted] = React.useState(false);  const [restore, setRestore] = React.useState<ActionStatus>("idle");  const [back, setBack] = React.useState(false);  // a new round after a restore starts the hold button afresh  const [round, setRound] = React.useState(0);  const timers = React.useRef<number[]>([]);  React.useEffect(() => () => timers.current.forEach((t) => window.clearTimeout(t)), []);  const later = (fn: () => void, ms: number) => timers.current.push(window.setTimeout(fn, reduced ? 0 : ms));  // how much of the name is right so far: a wrong letter sends him back to where it still matches  let matched = 0;  while (matched < typed.length && matched < name.length && typed[matched] === name[matched]) matched++;  const full = typed === name;  const rise = name.length ? matched / name.length : 0;  const mode: BooMode = back ? "back" : deleted || hold === "success" ? "gone" : hold === "holding" || hold === "pending" ? "hold" : "type";  const mood = back    ? `Welcome back, ${name}`    : deleted      ? `${name} is gone, mostly`      : hold === "holding" || hold === "pending"        ? `Goodbye, ${name}`        : hold === "success"          ? `${name} is gone`          : hold === "error"            ? `${name} is still here`            : full              ? `Last chance for ${name}`              : matched > 0                ? `${name} is fading`                : `${name} is safe and sound`;  const change = (next: string) => {    let m = 0;    while (m < next.length && m < name.length && next[m] === name[m]) m++;    // a letter that doesn't belong: he shivers on his way back down    if (next.length > typed.length && m < next.length) boo.current?.shiver();    setTyped(next);  };  const doRestore = async () => {    if (!onRestore || restore === "pending") return;    setRestore("pending");    try {      await onRestore();      setRestore("success");      setBack(true);      later(() => {        setDeleted(false);        setBack(false);        setTyped("");        setHold("idle");        setRestore("idle");        setRound((r) => r + 1);      }, 1400);    } catch {      setRestore("error");    }  };  const gone = deleted || back;  const tile = (    <div className="relative size-full">      <div        className="absolute inset-0 grid place-items-center overflow-clip rounded-[16px] text-[21px] font-semibold tracking-[-0.02em] text-white"        style={{          background: avatar ? undefined : color,          boxShadow: `inset 0 1px 0 ${mix("white", 30)}, 0 0 0 1px ${mix("black", 12)}`,          filter: `grayscale(${gone && !back ? 1 : rise * 0.95})`,          opacity: deleted && !back ? 0 : 1 - rise * 0.35,          transform: deleted && !back ? "scale(0.86)" : "none",          transition: reduced ? "none" : `filter 380ms ${EASE_OUT}, opacity 380ms ${EASE_OUT}, transform 480ms ${EASE_OUT}`,        }}      >        {/* eslint-disable-next-line @next/next/no-img-element */}        {avatar ? <img src={avatar} alt="" className="size-full object-cover" /> : initials(name)}      </div>      {/* where it was */}      <div        className="absolute inset-0 rounded-[16px] border-[1.5px] border-dashed"        style={{ borderColor: mix(PF, 55), opacity: deleted && !back ? 1 : 0, transition: reduced ? "none" : `opacity 380ms ${EASE_OUT} 120ms` }}      />    </div>  );  return (    <section aria-labelledby={`${baseId}-title`} className={`relative w-full max-w-[380px] rounded-[28px] p-2 text-card-foreground ${className}`} style={CARD}>      {/* Its natural width where the parent sizes to its content, without forcing it on narrow screens. */}      <div aria-hidden="true" data-natural-width className="grid h-0" style={{ gridTemplateColumns: "minmax(0, 380px)" }} />      <div className="@container w-full">        <div className="relative overflow-clip rounded-[22px] text-primary-foreground" style={STAGE}>          <Boo ref={boo} rise={rise} mode={mode} holdMs={holdMs} reduced={reduced} tile={tile} />          <p className="absolute inset-x-0 bottom-2.5 z-10 text-center text-[12.5px] font-medium text-primary-foreground/85">            <TextMorph>{mood}</TextMorph>          </p>        </div>        {/* the confirm form and the after-delete panel trade places in one surface */}        <div className="grid">          <div            className="col-start-1 row-start-1 grid"            style={{ gridTemplateRows: deleted ? "0fr" : "1fr", opacity: deleted ? 0 : 1, pointerEvents: deleted ? "none" : undefined, transition: reduced ? "none" : `grid-template-rows 460ms ${EASE_OUT}, opacity 220ms` }}          >            <div className="min-w-0 overflow-clip" inert={deleted}>              <div className="px-3 pb-2 pt-3">                <h2 id={`${baseId}-title`} className="text-[15px] font-medium tracking-[-0.01em]">                  Delete {kind}                </h2>                <p className="mt-0.5 text-[12.5px] text-muted-foreground">                  This deletes <span className="font-medium text-foreground">{name}</span> and everything in it.                </p>                {consequences && consequences.length > 0 && (                  <ul className="mt-2 grid gap-1 text-[12.5px] text-muted-foreground">                    {consequences.map((c) => (                      <li key={c} className="flex items-center gap-2">                        <span className="size-1 shrink-0 rounded-full bg-red-500" />                        {c}                      </li>                    ))}                  </ul>                )}                <Input                  className="mt-3"                  label={                    <>                      Type <span className="font-medium text-foreground">{name}</span> to confirm                    </>                  }                  value={typed}                  onValueChange={change}                  autoComplete="off"                  spellCheck={false}                  autoCapitalize="off"                  disabled={hold === "holding" || hold === "pending" || hold === "success"}                />                <HoldToConfirm                  key={round}                  className="mt-3 w-full"                  style={full ? DANGER : UNARMED}                  icon={<Trash2 />}                  duration={holdMs}                  resetAfter={0}                  disabled={!full}                  labels={{ idle: `Hold to delete`, holding: "Keep holding", pending: "Deleting", success: "Deleted", error: "Hold to try again" }}                  onStatusChange={(s) => {                    setHold(s);                    if (s === "success") later(() => setDeleted(true), 900);                  }}                  onConfirm={async () => {                    await onDelete();                  }}                />              </div>            </div>          </div>          <div            className="col-start-1 row-start-1 grid"            style={{ gridTemplateRows: deleted ? "1fr" : "0fr", opacity: deleted ? 1 : 0, pointerEvents: deleted ? undefined : "none", transition: reduced ? "none" : `grid-template-rows 460ms ${EASE_OUT}, opacity 260ms 120ms` }}          >            <div className="min-w-0 overflow-clip" inert={!deleted}>              <div className="flex items-center gap-3 px-3 pb-2 pt-3">                <div className="min-w-0 flex-1">                  <p className="text-[15px] font-medium tracking-[-0.01em]">                    {name} was deleted                  </p>                  <p className="mt-0.5 text-[12.5px] text-muted-foreground">                    {onRestore ? `You can restore it for ${graceDays} days.` : "It’s gone for good."}                  </p>                </div>                {onRestore && (                  <StatusButton                    variant="outline"                    status={restore}                    labels={{ idle: "Restore", pending: "Restoring", success: "Restored", error: "Try again" }}                    onClick={doRestore}                    className="shrink-0"                  />                )}              </div>            </div>          </div>        </div>      </div>      <span className="sr-only" role="status">        {deleted ? `${name} was deleted.` : full ? `Name matches. Hold Delete to confirm.` : ""}      </span>    </section>  );}export default DeleteWorkspace;

"use client";import * as React from "react";import { BOO_ART as ART, BOO_GEO as G } from "./boo-art";/* ───────────────────────────────────────────────────────── * BOO: the ghost of the thing you're deleting * * An illustrated ghost who lives in the workspace's tile, * rigged in code: * *   rise     as the name is typed, he rises out of the top of *            the tile, worried (`rise`, 0 to 1); a wrong letter *            and he sinks back a step *   hold     holding Delete, he waves and drifts up out of the *            stage over the hold; let go and he drops back *   gone     deleted: he's away, and a moment later peeks up *            over the bottom edge of the stage *   back     restored: he dives back down into his tile, shy * * The scene is drawn at 364 × 184 and scaled to the stage. * One frame loop outside React moves him and sleeps when he's * still; his float is a compositor animation. * ───────────────────────────────────────────────────────── */export type BooMode = "type" | "hold" | "gone" | "back";const W = 364;const H = 184;const K = 0.44; // his drawing scaleexport const BOO_TILE = { x: W / 2, top: 92, size: 60 };const RISE = 80; // how far out of the tile he comesconst AWAY = -140; // above the stageconst PEEK = { x: 320, bottom: H + 2 };const clamp = (v: number, a = 0, b = 1) => Math.min(b, Math.max(a, v));const easeIn = (k: number) => k * k * k;type Spring = { x: number; v: number };function step(s: Spring, target: number, dt: number, k = 170, c = 20) {  s.v += ((target - s.x) * k - s.v * c) * dt;  s.x += s.v * dt;  if (Math.abs(target - s.x) < 1e-2 && Math.abs(s.v) < 1e-2) {    s.x = target;    s.v = 0;    return true;  }  return false;}export class BooEngine {  parts: Record<string, Element | null> = {};  reduced = false;  mode: BooMode = "type";  rise = 0;  holdMs = 1100;  holdAt = 0;  holdFrom = 0;  goneAt = 0;  y: Spring = { x: BOO_TILE.top + 4, v: 0 };  peek: Spring = { x: 0, v: 0 };  tilt: Spring = { x: 0, v: 0 };  raf = 0;  last = 0;  observer: ResizeObserver | null = null;  floats: Animation[] = [];  frame = (now: number) => this.tick(now);  part = (name: string) => (el: Element | null) => {    this.parts[name] = el;  };  mount(reduced: boolean, rise: number, mode: BooMode, holdMs: number) {    this.reduced = reduced;    const host = this.parts.host as HTMLElement | null;    const scene = this.parts.scene as HTMLElement | null;    if (host && scene) {      const fit = () => scene.style.setProperty("transform", `scale(${host.clientWidth / W})`);      fit();      this.observer = new ResizeObserver(fit);      this.observer.observe(host);    }    if (!reduced) {      // he floats: a slow bob on each pose, under whatever the frame loop does      for (const name of ["worried", "wave", "shy", "peekImg"]) {        const el = this.parts[name] as HTMLElement | null;        const a = el?.animate([{ transform: "translateY(0px)" }, { transform: `translateY(${name === "peekImg" ? -1.5 : -3.5}px)` }], {          duration: 1500 + name.length * 40,          iterations: Infinity,          direction: "alternate",          easing: "ease-in-out",        });        if (a) this.floats.push(a);      }    }    this.set(rise, mode, holdMs, true);  }  destroy() {    cancelAnimationFrame(this.raf);    this.raf = 0;    this.observer?.disconnect();    this.observer = null;    this.floats.forEach((a) => a.cancel());    this.floats = [];  }  target() {    if (this.mode === "gone") return AWAY;    if (this.mode === "back") return BOO_TILE.top + 6;    // at rest he's tucked a little below the tile's top edge, out of sight    return BOO_TILE.top + 4 - (RISE + 4) * clamp(this.rise);  }  set(rise: number, mode: BooMode, holdMs: number, now = false) {    const was = this.mode;    this.rise = rise;    this.holdMs = holdMs;    this.mode = mode;    const t = performance.now();    if (mode === "hold" && was !== "hold") {      this.holdAt = t;      this.holdFrom = this.y.x;    }    if (mode === "gone" && was !== "gone") this.goneAt = t;    if (mode === "back" && was !== "back") this.y.x = Math.min(this.y.x, AWAY);    if (mode === "type" && was === "back") this.y.x = BOO_TILE.top + 4;    if (now || this.reduced) {      this.y.x = mode === "hold" ? AWAY : this.target();      this.y.v = 0;      this.peek.x = mode === "gone" ? 1 : 0;      this.draw();      return;    }    this.wake();  }  /** A shiver when a wrong letter sends him back. */  shiver() {    if (this.reduced) return;    this.tilt.v += 260;    this.wake();  }  wake() {    if (this.raf || !this.parts.ghost) return;    this.last = performance.now();    this.raf = requestAnimationFrame(this.frame);  }  tick(now: number) {    const dt = Math.min(0.05, (now - this.last) / 1000);    this.last = now;    let busy = false;    if (this.mode === "hold") {      // up and out over the hold, slow at first like he's reluctant      const k = clamp((now - this.holdAt) / this.holdMs);      this.y.x = this.holdFrom + (AWAY - this.holdFrom) * easeIn(k);      this.y.v = 0;      busy = k < 1;    }    const settled = [      this.mode === "hold" || step(this.y, this.target(), dt, this.mode === "back" ? 120 : 150, this.mode === "back" ? 15 : 17),      step(this.peek, this.mode === "gone" && now - this.goneAt > 900 ? 1 : 0, dt, 140, 14),      step(this.tilt, 0, dt, 300, 10),    ].every(Boolean);    if (!settled) busy = true;    if (this.mode === "gone" && now - this.goneAt <= 900) busy = true;    this.draw();    this.raf = busy ? requestAnimationFrame(this.frame) : 0;  }  draw() {    const pose = this.mode === "back" ? "shy" : this.mode === "type" ? "worried" : "wave";    for (const n of ["worried", "wave", "shy"]) (this.parts[n] as HTMLElement | null)?.style.setProperty("opacity", n === pose ? "1" : "0");    const ghost = this.parts.ghost as HTMLElement | null;    ghost?.style.setProperty("transform", `translate(${BOO_TILE.x}px, ${this.y.x.toFixed(2)}px) rotate(${(this.tilt.x * 0.02).toFixed(2)}deg)`);    const p = clamp(this.peek.x, 0, 1.2);    (this.parts.peek as HTMLElement | null)?.style.setProperty("transform", `translate(${PEEK.x}px, ${(PEEK.bottom + (1 - p) * G.peek.h * K * 1.1).toFixed(2)}px)`);  }}export function Boo({  rise,  mode,  holdMs = 1100,  reduced,  tile,  ref,  className = "",}: {  /** How far out of his tile he is: 0 inside, 1 all the way out. */  rise: number;  mode: BooMode;  /** How long the Delete hold lasts, so he's out of the stage just as it confirms. */  holdMs?: number;  reduced: boolean;  /** The workspace's tile, drawn by the block; he lives behind it. */  tile: React.ReactNode;  ref?: React.Ref<{ shiver: () => void }>;  className?: string;}) {  const [engine] = React.useState(() => new BooEngine());  React.useLayoutEffect(() => {    engine.mount(reduced, rise, mode, holdMs);    return () => engine.destroy();    // mounted once per reduced-motion setting; the rest arrives through set() below    // eslint-disable-next-line react-hooks/exhaustive-deps  }, [engine, reduced]);  React.useEffect(() => {    engine.set(rise, mode, holdMs);  }, [engine, rise, mode, holdMs]);  React.useImperativeHandle(ref, () => ({ shiver: () => engine.shiver() }), [engine]);  const img = "pointer-events-none absolute max-w-none select-none";  const pose = (name: "worried" | "wave" | "shy") => (    // eslint-disable-next-line @next/next/no-img-element    <img      ref={engine.part(name)}      src={ART[name]}      alt=""      draggable={false}      className={img}      style={{ left: -G[name].head * K, top: 0, width: G[name].w * K, height: G[name].h * K, opacity: name === "worried" ? 1 : 0 }}    />  );  return (    <div ref={engine.part("host")} aria-hidden="true" className={`relative w-full ${className}`} style={{ aspectRatio: `${W} / ${H}` }}>      <div ref={engine.part("scene")} className="absolute left-0 top-0 origin-top-left" style={{ width: W, height: H }}>        {/* he's only seen above the top of his tile, as if he climbs out of it */}        <div className="absolute inset-x-0 top-0" style={{ height: BOO_TILE.top + 1, overflow: "clip", overflowClipMargin: 0 }}>          <div ref={engine.part("ghost")} className="absolute left-0 top-0 will-change-transform">            {pose("worried")}            {pose("wave")}            {pose("shy")}          </div>        </div>        <div className="absolute" style={{ left: BOO_TILE.x - BOO_TILE.size / 2, top: BOO_TILE.top, width: BOO_TILE.size, height: BOO_TILE.size }}>          {tile}        </div>        {/* after the delete he lingers, peeking up over the bottom edge */}        <div ref={engine.part("peek")} className="absolute left-0 top-0">          {/* eslint-disable-next-line @next/next/no-img-element */}          <img            ref={engine.part("peekImg")}            src={ART.peek}            alt=""            draggable={false}            className={img}            style={{ left: -G.peek.head * K, top: -G.peek.h * K, width: G.peek.w * K, height: G.peek.h * K }}          />        </div>      </div>    </div>  );}export default Boo;

/* Boo's art: an illustrated ghost in four poses, as WebP data URIs so one install brings * everything. Each pose is placed by the middle of the top of its head (head, 0). */export const BOO_ART = {  worried: "data:image/webp;base64,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",  wave: "data:image/webp;base64,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",  peek: "data:image/webp;base64,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",  shy: "data:image/webp;base64,UklGRpogAABXRUJQVlA4WAoAAAAQAAAAtwAA5AAAQUxQSI4KAAARwMds2/Kp0a4r9xsyNAMhQ6b9ZEpqMHUXYF3Y0K4Rug58Buu7FRpYd4N148u6C7CupO7uLSUDWULdaGYIE5iQ975z/QHMK/P+7r8jYgLQlaQVRkyeZoWRyCtpRhy6r39w6NjhU08bPnqgD4emGZkQmuHg4uhXrPzmn299aNvOZ0f37t+/59lHH/rHj9ZfuuS0fhxMYypoBoCnLVv3p4fGVPPE9qu+9a75MwHQmAUagP6XfOq2Azo43KOqu4cOjp2/WTkXAI29jwZg+uIN20JSlB6hmiPCXZL2XHXJ8QCMvY0GYMG6ByTJI9R8uEsa23jxAGDsXTSg77+vK6XwCLU1wiXtWj8HMPYmGjD7vQ9J8lDLw0Pa/dljAWMPMmDW2p2Sh6ZkuDT6vdMA6zUkiv/dLnloyoZL+74+ALKX0IDFt0kemtLh0sgSwHoHgXkbJQ9N+SgVvxoG2SMMXD2mCHVilNr9LsB6gmHOPyVXZ7r0h2Nh3Ufi9Y/KQx0aricvAtlxBnzc5epYV3kFwE4zzN6sCHVuuL43DeywAvPuV6kujlJ/7od1VoFTd6pUR5e6ciasowwvf1Kuzi510xCskwq8YVyhDndtPR7WQQXeMKFQp5d64N/BzjFcuE+hjnfdPJPsGMP5Ywp1vmszjZ1CzNmpUA8stR7WJcTsu+Tqia73wLqDLP4hV2+MOPAaWGcY1qlUrww9OgR2hGFplOqdrr8Wxk4g5jyr6CFyXQrrBOOf5eql4XsXgh1guFSu3hraMUBOOXLeeESPUamvY8qR2CxXr42YOJmcYobXR6j3un6GKUb2P6BepDjwUtiUMlwmV0/SndNAM3KKkIO7InqSXB8zHMyCnAKGNXL15gi/b8vXl502AwDM2DJy8NGIHnXYiR1/XnteAcDYKsMn5OrZEeEhSQfuW//SAjC2h5z1aETvOmSEuyS/65JBgGyL4V0KZTA8pEe/eipgbAVZ3Bk5kBQu7f3VeYC1wbAgQnkMl/avmwFjc8TX5YmQwqX7Xw6wKWLmdkUqpHCV66fDGjIsCVc6Q7r5DBgbIX6mhEiuvStBNkAc+XhERuTSZ0HWZ1gqV07DtYFkAxvSIrl+amRNRHGPIi0qtQHGuobHM6NSH4HVY1iuUGLD4zWwWoj/l2dGoX8NkDUQdociNXL9CFbLsaPZkWs5rJrhIoWSG9o5g6xhtTw7Cr0PVsMPMhQjM8gqxBZFehRaBqtAFA9kyGMLWWlgZ4ZC4yeDVeaOZUiu96GYnOElEUrRJrDK65Si0AOGKm/N0rODlVbKczQxXKHAJTmStKCC4bNJCi2q9NU0La70rTQtqvSdNL240rdyFCrPqPTVLI0OVfpslkb6Kq3N0hawykpFhlzrUFRZkaPQxbAqb05RaO+xYJXXpcjjVhJVXqoMu9bAKhAn71ekJzQ6B6w0+HSCXBtBVOrbnqDQRbAqAG7Ij+uuaWQlYpM8O6HlMFQ2fD89obumkXV8JEFvgKGOtyty47rJyFoWhFIbocUw1Egcs0eRGddfSdQzfVtqIsZPRj0gNsoT41oLQ72Gj2QmdMc0Y21LFWkJnzgfRG3zS6XV9VkY6iaOHVMkJXR9n7GBvq1Zidh9PIj6iS3ynJT6bxRosMC3kuL6A4hmLstJaGSIzRiWKhISMX4WiIbOC0U6IrQchmaJOWMZ0RoYGuvfng/Xx2BonLgqHa6NMLZhszwXoUdmk2je8L1kROxfCEMrPp0M11dhaMcluQg9NZtsyVuz8U0QLVmqyITrzbS2XJiL0MVozSty4VqRtve051XZ+HB7FmXj6+1Zmo3NYFtWZeOqthT4hDwToYemga0w/CAbzx3VDsJuU+Ri/KS2DD2bjXIBrA3GxR5KZegNLcF6lblwva8V5PQHIrKxvhWGt0epbPwJbI484gFFMkL3FGBjhncplI4nj2yO7N8eCSnPbK7AaoXSGXozrCFi6NlIiOtjKBoy/l6hjPwCbMbwHpVKaOiGhoiTRiNysmsm2ABZXK9QTvbPa8TwCblyGloMq8/wigmPpLjWNED8+y6F0rIRrItW/EGurIbuI1iT4X1yJWb3UXWRc58rIy8KLYTVhE0qlVjXu1DUYljipXLzA1gd5KwRRWpCdxSo0/BpuZLzwjFgNeKo3RG5UcQSWDXD+xRKruvLdRDXh2cndD1ZiRgeV+Rn99FgFcPHFEpv6M2wKuRVGXJ9D6yCgR0ZCm3tA6sMj+aoPAdWZf5EhuRag6LKKzyU4NA1ZJVFkaS988AKL8+RQu+FVRgeVWTI9VewQv/WHIVGh8BJET+TZ0ih/4ZNyvBmRYpc/wQnRfaPRGQotP9kcDIwXKYyQ3J9BDYpsv9OeYZCNxScFIiTXpCnaN8Z4KRgeMUelflR6MOwycEwf5vCE3RzQU4OhtnfmVB4REiKiJxIE+fBKsCA+b8ZVXZdH6sGEhi+4k87xz3K8SdHkxK6EqwEkABmzj3zvLPmDd2vSMrjg2A1gEYc8qURSsrEOfUAIGkFfibPiUKvg9UEgJzzQkRaljdh+LJCSXWtaoAYHou0hFY2skmhvLy1PsPScOW1nF8f+x5QpCW0cyZYk+HtCqXV4zcgaiavi8SE3gqriZg7rrxE7JgJ1mRYpVBaXf8NQ20/kKfF9RsQNRO8Q5GV0MggG+gbSYtr7/kw1Dc9La59S2BogPflJFyPLoKhQeIX4QkJ6a/HwNCk4S2KfLgOrAYMjRIz/xWRjVJPLgaJhg2XqExGqevmwtA4WVylMhWuTX0wtJD49zvkkQfXH/pgaCUx8BvJIwmuq44A0VIC//2IFF4e8IgI97IM9/DSo+eEtg+CaC2J/vfdeUBS6PBehiRFRE+JGJ8PQ5sNsPPf+9XNd41svfUfm7732fcsfdVLFy37yOaRkKILIqIlrjUo0G4aDu7rn26Y9MAbNu+Tx9QK95DkHi1wXVkYWwaQZgQA0g5PAGf+Q4qp5JJ0YJ8kRTQVsWcYxNQkSUyaRnDNfvmUiVDc8OELzzxp4YoNu6SIhrQMRHeSmL9VPkVC+sNCHHbW/9wneROudSjQqQWOfUQ+JUJ7lgM0I80MmL5mXB61ua4rjN2CAmfujpgCoacXwAyHpQHnXCd5Ta6n5oDoWsPiiYjWRexfiAKTpsFWj8mjjlK7F4Lo3gKr5W2L0AoUqErg1H9KHlUiNHIWDF1s2CRvV0SsgqE6DVyxXfKYTLj0k9kwdDJ55DZFmyJiFQrUSmDgE09K4XFId+nxtwKGjiZeMR7RItelKFC3Af+++qYJHf6F7x0NEp1t+LTK9rg+jQL10wCed8XGO3c+ev+WDcuGAEOHk31bVLal1LdgbACgAQD7Z0wDABKdTswZUbQiXL8AiYZJIwDQjOh6w/mjES0I1/eMRBtJEj2xwNvlzUXocyCRywIbVDYVKi8BiWSSR1yvsplSY0thyCcx+1Z51BehrWfBkFFi1iYpagqXfjaIAjkl8OFxlVFDuLR9KWDIKokFt0keMakIl/Z+cRZIJNZwxNonJbnHod0ljf3kVMCQWwJDq68vNdnxG9bOBYzILg3A+Z+9cscL4/v2PHXXz1bNA0AiwzQA6B+aN3fOAAHAiCzTjDi0FUQvBFZQOCDmFQAAsF4AnQEquADlAD5hKpJGpCKiJqey++jQDAlN3BgV5YBRNnZefqJU/QWjYW0P+D629vz5iP2H9YD0k/3b1AP571Iv9u9Q79gPTk/dL4N/7F/yf3K+A/9if//7AHoAcNN/Vfxc8V/9B0rPwz2z3dnNV+Ov2nFH8vtQv8p/qn+p4GuznoBez31Xv99T7w97AH85/qfFed9frx8AX9I/uf/k/w3sB/9/+z8936B/kv/h/nPgI/lf9S/6n+K7UX7ieyl+wR2Nd74oaPM+P79TBDBRn/fG1OzQ6/M36ay4pYUgZ+/uCuZsnGXwAUH+AttwMvl0jmPTxa1/fTSOz1YyFwWkP6P+3N3zENTOAYi0GJjEEr+YuihaNI9H6AUGHV6j9aLtD4oNXBou2XmHy7IkCYSEzxBI+r4XxbTmzjvaU3m7g7Y214cH90vYHJYfCBIcXv3nzJvpKxDC2XgAHDPALcTFATGYgYllFQip4TGtyG/Trdf/+h5iDfn/mBy7qJVp18gjm4aQpgNh0GxBUM0RDbQ9l6aGDQAd4C3Wr9P+K5Qq7k6vx1RD5ARhV3Ra5yPjMCuEk+o0VSLR6l9GWuXnLGBeGoWthWZOsvMBIGmAJM37dMuHPigtGnyFRpAQs4eHmGWz5qL36nWylsK9+DIcS10/HQMsL3qTotKTVKXSy3FKn+/apEDhKlxeEPm/QKQaZYOcVfuu0MjD8z17gjMR5z/yIa4AvdnudjVJAyltP9w7ritroegzgR7wEJ6aP26XpaA29ju0jay48CWVvKxjZ6KjN6G2OS6qGVrA6HSkwulV0k+UewN+TN2CDzBKW1Bsi/yX/W4WnzF5t6ZPACMwmjZ6m+77ax7PPQ/SU/6DYAj/6DgXW+wxE2Ubm8ZtubZJjr/NcusKCBeaIKvWybwqnhpeughbVFLkUIUYvgFyH3eFigERDk6EGkBakOo2+scthOZw3Zgln8zmy0aOgmNzs6czdWWU9OwGMdH5JB300QdmU1Rg0pm8ua16nqSXK7zIAAD+3waHPiS/7QShbvb5jVCT/E/m4c9zpm3px6GavZqhiYhnNnCZNvnJUkRvSB8MWYzPiEOyBkEdjT27qvFyBjmRE1YKRGLazR1q4es02Bn+nue8w+nW+yR8Wh9GGZH5fPRe2oby1Qk2WdKc5y2M7eIC8aNoBATzT/PTfPK7HkUlQFD5j+l1vGLwhp+V0b6WnKh92QQ+NOQ0JDNhh/UZkXrahci77oji3b8w68bvVFkI0su/FsbGLNqPHwT/kie1ZcCXVVzFRv3jQ1oj0LVN65uRfEiF3IeMSXhctc5HUtcD/NAsWEY0UwdzOxg7N5zfrZD1WQm1MRLOLtIDJARR5XQFAAgm/maGM9dxYTodsVgivt930v7mwcL8Dlwf24bdpThmOs7DAgRuzIOl9LkSw1M6q9KtR87jVl68MbfkWdnRBZdRyxj4ul9yxrymk0ARFDURFd8+Ho9wOQBqPvObzWuIGawYp6K4DFEzay2rnyDKZ1jSI8Ojfg7XwWgvVAL27CqZF2h1sXq/fGcD0CW+lgif56oCra42Qb5LCvFJwjoo6T2S4z+wV/LdqnRRmpZmopht6J9tRfijexr7NLu78XYPthgionEMOnyRgMKvyOJyPRC8+xgaZF5s2e76NuQIgsh+Bjsh31kvC8NQrUffytVxgr/SJ+Ne8ay+YiOCWcgkaZZ63DHsOl7zl4B+x1cVVC7T07jsYnzuaZZ96OfYM2UgH4dSOeA1GhPL8w4BBg6+5LuG57WZyd2hFtESTpHf13+BRS+UfkBvdp3BDpdTQcE3Pz1aBG92nsQW4PJNX3bqDsKgeeq62B2pqxw4KjtN/AnvyuFBw+ZR6tzHZ7CeMnlBgsGVuWgX2RpNXmiWTgoWA8TqmJHEoABMnOKkJuM6mIDNjc5JjJ9iuoLhvF3nK0pTf04hwW11S+wa6gV/SD9B3TjQ1mIwQ0PjClzl1f2c+Bxh5+SFiGAnWJLNGX5/MB7J3sO7NE6fRZXZ0gwwtB/z30fDWb5W+FwbGHfVuUdBCJ+V57Cva/vvHrqVzw/k9qJpPRobb3S6hfnz+P+C1BcaLSYugNf6OFg7Xzb+zOIut7Akpvjpdyi8kOmIaiouNUIqLX13kWIUIoP8X1gjOLzbZqE4yoxi0FLSQuIYmVzkTRI7jDyRB8VuD+nzai2XI+1cUGxma7ZdDwmiXFf7y06bdw7clafgXN++4qqp9at0/3oopu/l0/ZH7VTHX56so14brPFZWhqo6XtXrKovbICEpIfT1oK9/I0Nxzmvgt4BCQmQQpdqYJsi/6uHiGbk4cX96CrFaOxjtyjbFxxcS99CLV3608oHgVr9DaTw43Uij6zC3q4o1uP7vdt5YrxnJivAubwm5lHW6O1fWvD1sBs82E3F07JEcGnZKoSzIqHGIuCT6zsuKIOBa0syB9Wjb9P9Dz3+8UvydKkHous1fab7Fh+cOwzNOKj6p9s466sq5ESPY/Zk4XQB0lEJgXXNJKgJQU2Ca0b3ae/sl3jUwFLaFdEc0YN1r2tXn+2LcveowQFq9VhJeb6MZb6gdBVPU/TeUc4iM30fM3mB8FOXhaTXRh7cmJXXFX/dnpEp7ng9HxALAMgcgYx4ASuaplIrFFs8/z/YIPkW1CgJZPySdOFQ/B7ieSr21l8hKjuM0oNVNWEbytftKbjj/AH4Y+TDK334v5Eugno9CQ/Q3z90mseTaq2YirkmLxdxHT2FxPXVSeF+852KoO8MiLkPd8fLlBGQarVCd/ITaG31QhqW/UuL/AvJPjS0KG81ry4WJwf6Ulwj9o+5fwDazIpPR+dpfVqifZb1Z2+rqxFLmA/i5wA6TCAn8IaKqTVlZFwcsaVb8NeSQjfLdAIfIJH4afd/Hj4Fp+1blk654AHlYkRqTmbf9wP/xF5aowR7E6mtbkfoS61upvPn/xt/OXV/6GfhK4wxxwFjSmEV9Gy/o83P84aT5EtYjHYYyiGvQjEM00nEx3D35oVP5j36Nxp26uYt1qvUIj9S9urR3kiyN8FdJjU0s7epd7mECvO9JzHBImus62bYBem0H3+Ri3SVTQr3HCpyOjFCBLQNBxnEhft1y2/OtiGj3jxGU7wgbzIMTMNl6P+9Dq6RRICfts3ZNA+N+WtP2Xo/CElLzwFjxsShy0O3J1KhJF+fqIgR6Mv59un7Pp18oQIkpVnlk22HxLLGMcFG3K7a0eSkQLT9XLhHGXHcPcYFcFHZqEZB6yP5F7Js5f0kaWJ2SgXl2bsJWInQQKR4Kyec4eB3A3DlpXqSkmQCGAnsX0wl+2/ypMAAGOjUOCLuwy7o6rdRg3/MHOoLxTcA8BpgaLWxlkia16Mi2v299g41D/upy0dXXeOFCPVbqaLmQYkyvs0X0Ty7zKJM2WyYM7FSw3Okx2MvMHDgsEuBtl85R1FjMb6gOIuQKN4DsGQRScAQ6lT0NpNOkQOLEcBePkQCltM7Q9cM3za7BxlzSeoAND/UfxPXyBaj3Aa29lJOdlVmFxyLM/q8sD2+JC9fWuyGfeTM04Lj/ra7JtmAFxLkngCsUeoBN1oQSGUTXBFXKEeHLkG45+ZrQvQrfc8TAmk8McervrLn7/0hG1Dlm4cM1O9EReU1jKP5N4OVEEDnunqI4e2YQCvY48nHJds7TJszDwM198i4FTc5KsfaQ0L/b51Gw0BvA7otrsjjFHVibv8lMs7abgt8tuwsCRlw+fRcH9kkxxwQXCXuBUvO5Bq9eop3PVC7BO6UazcwzCyhdYXEZ+AJ/llqMlvB6wDBu2xBeUf2/mecfUL7Z11fGSf9PYdeyrDLj6PpQf0vfXe/tES3xJdRE4pXq8E+26V2faQI4otlVVelSsG+uaB8HZOq7htatFQJ2i7CvdHtfNZPSKb5E8/Hw9dtSpgHRqLh/ivAnhdayqdJus5ip7nwkhowd0XDPMvngtzo+wTNAOyqhuTcFNfa3NpqQnPFg6ht3SQ5UrFIGf2cy9ZSah+XukJLqJn7jnadcW7TcUGGMJjcw53NUEnxm/tUVzEpjg3AC3tGem0Ri2D7TJmHNctjcpzW7e/Xv92Y/yzS4Ss3kKBnYya/HB99OPO0v4ocbbYQvF/FJWPYHaRaPcjP1xreeF5oifv7IjBgItPovIWQhfqCZ5SgvVchWN5L8HRleIGJyfAMEJFcOD3GzF0STtIv5kI7+Ju3SilLyffSZ7qsYXmEK9I3Bzw60j9Tzj7nKCQiMx7vrIKgToT2mXIDKM9N7/kUws6GV5xD/nqYrt01hutxrblGmsekwjnFKtK4z373x4N7/YZPhb6ATna71wXoTViIpYQnaVy2lUElDvXDP6EdB/nrbUn+o/4PR2lhg7EnMjfkzb2ocpcvrM1E9DQZW8p/DJ9vDIenmp9VCVYvOB/10Rcww69aHY2jz9PbXUMKfj70M2oN3cuP30KxR7yLd0R2KiRDcNwANdPGfsQ/vsWawKKCb96b8IaT6g4st+cyEzzNMt5GE//81EQ33V/RSWu8IpYokNfGQRHUOg0CIMq6KGcJPizkIszS2SpiJRSwYJZAykwtKLO5oz7Tla0v1lgkKT0IeJVscjEkAIRY3izG8/JSqVZzvc77sYjSAMBzqbwN3DubO5M3yfHjzs5oRqcUAG3avpBo7TkM8+pzv3S/rdQ8+0qHwC3UgIRPXWFeOZd2VuusD3d9ZbdTPmDm4XbXeMCOST/YL3FZHWngVT33k7REf71whpHuHeDu2qHDrOUbTDTONLrkzolRTdNpC933O+LuhCKjohGpfbQRzScXlXhCxGPa+rwRYN/9+MODITym5pxLN05Ftjac3CJzpbcYOvRZHTqqKH/2HLjf4A6LU8E/Gi/Wcu2/8teJqhUBnVsXPTzupL5sGMuDBI2214YSJbhNoQO/hMZWdK6W7awQoGYYaQ7LIvcEfNDymhUBucEyh+SR5bkBmCqaJlgnFMd49TJHKGEC+Ne+sIA4RpE+KE5sAHlafNtOiSq0b5VwLtFOYK4BiAJlgqTIWgfFSZiJ3MhsKBt7lvsZOi8UDYJZuWCcjA0ONwTT/JWivZOOaRB7Q7ii9YOmKQ5lZvjMn7QAr+3Cqtpcc0yvZ7bzgnDg7inegS3CISUQQG/szb/wghgTgvjsEc321CyCmD8tOh3dFU3HxiBxpWIUwnh7+dPR2y4cJCGGlueGLEq90PAYeOAkMjPW101e+QAjOgA+oz/+dvq4tetjgSiVo0PG/qfwj7dgTii4Vakz4CI5RcvM5XLdkJAcAg4OmHP46GBfYsXikhH3EoXNet846AyLCUTg5tVBGDYih8mfGOLKkvSlQR3HzyfyEIuKZ6HsEY2McUUkfJuWwksmpSzJJYYX1hDEY4C9/1IUnBFXNDxsoQEl0g0CWQBzhNrTiNWP2kTkaVQjsXxshtK6kEIB/SCE3Ep/qwBH+y/ZJGeHSTFjLAY3CaMCVCrcRaaIlP8JmjlT/OTNZdFLfyZUxKjwPvYIAM+PpFcCFMaKAvYocmwmJTRiuK2kAdaFrSMSbL0JKccQWaP2aMctOZeDJzRJzyvvJN3CaKluavtxsZ3mFvIv2AeyGhOCZ92laXaGCMccyWTsA0/1mnAKd5R5fkH4Axut+4V+/rfkGQ/1fLJOViyPgp3P6L7EqMAB6y0qxvUIv2BkmHV1HLw1ebzJTpQBMF27u2rRZILtQ5HLmXXbEq1aBpnkB55G1BPoo1K5Dv0X577PjrjYNEQ7we9L10hMV26dTU3iJp3yruurVT5k3ZkXSI3qIQa/rN2D6nGvgtMaQJQX1X/3/+///NswfjXtUnT3TrogbkFPdewyHV1V46Vjjs7GuD7fGh8n9RqN264Uf8q8jR2cu0lIx9Ksih/84r9nZu8XXqkSmFwpPrD9+1//2LQZYVuurCGXZm2gDqg6noYswGgks6D7vszp5mnNRzmXc9q6eR070YdtcVz/4YQv0uW/5UVuKGdcWdFh0GANnfoK+hmyUPktkOd7V2yr/nil5ft4UdePBxtVMWf9E9NEQGoqfNupvA9xLDZH+6d3lMVt5YW2GwxGP2iH6qfrVcrguG3qYHm2/sbyYPkqOZEyAoeTh+7ZA2/ZFNjlLciZtFbrLMA1mIlUuTtWkOEpoPduSRUvUOs9S3QdBpzFmc98lS2Td0/TsCW0ijR7v7bMvZQjLq8nrPTks2F9Ii9yxPwy79imyZnnk+lgj7ZOu1OMq79LCCFXKX7Bftsl5EJnbp7dU/J/P2WBhMaGMMhD0hpVSBFLpQbjDsvKi+ZmjOzikGc25oxLacFs/bmVrKyW7xL+cqSs1khLCdAdy3ws3Wl75M1E19XjbjXLniFp8fZ7jtB9rQtsw82kzbecm6LT2ULaDHTfWy/0ydsGYdBnO4MgOdWu51dilk9VBUUoeUIjdUD9Mfk3Kbn+QHh8UUBbNKkNnt1RBjSAIeO5n91pjw8/U3xw3BAKkGWLjaAFlvAVeoSR4B7XUf46hjYJZp+GyGJQBAYT2vJD23gIEjE+kNlWv74Q8C0T+8fbCQZ5eu5BQmFoSr0H+hnQojosAz6eG8DqG0C26tgIehmEm0DIwBZE5rOv3oOw+fyq3nRwMVrkU3hRAylSuJih+bx1FvTdf1+LbSMepZJdoeJsz/XcAHGPa4L2vQbwwEu8q2Yl4SC8Hl3N8fEXiujQFVRtYNZOe/u8oiqQfMS3jmi8XBJAiJA97KNoQ36V8OJpiflIE9T9A5OSrkKoNv5plOl7b7qXdyW3OcyE4+CDU1FB9HT4uiEtKDCoxf0Tba2FxFpzvVlpYreY7zWUASDAAIMgIqfepwuxG+c2RkpE20JR8ungyxoCLJKEdcWwKojCC52Ae+WRgadXG3IcLYu8/GIACLW2ZvLgLk+LqhuWnjpDkXY74JBAn/F7AiuLqZ03BJ3Z1e1Pl6OmLaq/VEUx1LNCo6CnSwSxSKffTXu3mPXgFoUsIIf6sBuiTbnb7HGi0RA5VCOl9B6BATMzk5SKrcnF/I3ULC15KL7X//tSdOpc7ddeFcFQafWM9e8WMfL3VoVfvNDzcv/11tBiAM6PhnGDxv6+ZKmf5s9WPIIq3BrbCt/IuFHZrpB6rTV9HKbe3/X9M20VuNvLiLucUFLdILwb4PG8USQBypeaiUcoX8u+zIZFJPfykY65DDp3/QhCK9MnleND4rTtNuC/GAFQPcM7KdtiTXEsCEuNub/uvjOEeqPxY7HGX+a43XdmatcfP6FhiguVL/QtwoaqGniEsbsodJO1p2rheQgSDKdVDxg25nSWJ1cl0jPURzG97/bKcFAr4Pspj6QZ+TDu8p1bIaxR0DvAAAC5kcA53ic/XTTRe4V/Zp3Ru7htuYJVy479/g16N9n+vrFMgf5XfylazuOYN1rqUcEoHGYU9hdx6YYzXlFBwlxKulr+hz3se9PWdlI2hho/z9RNsM9TViMEyC+Avs/a08w/8f+GAAAAAAA=",};export const BOO_GEO = {  worried: { w: 197, h: 228, head: 102.2 },  wave: { w: 199, h: 225, head: 88.8 },  peek: { w: 216, h: 127, head: 109.3 },  shy: { w: 184, h: 229, head: 83.8 },} as const;

'use client';import * as React from 'react';export const EASE_OUT = 'cubic-bezier(0.16, 1, 0.3, 1)';export const EASE_SETTLE = 'cubic-bezier(0.22, 1.18, 0.36, 1)';/** Thrown things (indicators, thumbs): a slight overshoot on transform only. */export const EASE_THROW = 'cubic-bezier(0.34, 1.36, 0.64, 1)';/** * The press every button primitive shares: a 3% give that eases in and settles back. * Tailwind v4's scale-* writes the `scale` property, so `scale` has to be in the list * or the press snaps. */export const INTERACTION_PRESS =  'transition-[background-color,color,box-shadow,opacity,scale] duration-200 ease-[cubic-bezier(0.16,1,0.3,1)] active:scale-[0.97] motion-reduce:transition-none motion-reduce:active:scale-100';export const INTERACTION_FOCUS ='focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring/50 focus-visible:ring-offset-2 focus-visible:ring-offset-background';const query = '(prefers-reduced-motion: reduce)';const subscribe = (notify: () => void) => {  const media = window.matchMedia(query);  media.addEventListener('change', notify);  return () => media.removeEventListener('change', notify);};export const useInteractionReducedMotion = () => React.useSyncExternalStore(subscribe, () => window.matchMedia(query).matches, () => false);export function useInteractionActivity<T extends Element>() {  const ref = React.useRef<T>(null);  const [visible, setVisible] = React.useState(false);  const [hidden, setHidden] = React.useState(false);  React.useEffect(() => {    const el = ref.current;    if (!el) return;    const observer = new IntersectionObserver(([entry]) => setVisible(entry.isIntersecting));    observer.observe(el);    const visibility = () => setHidden(document.hidden);    visibility(); document.addEventListener('visibilitychange', visibility);    return () => { observer.disconnect(); document.removeEventListener('visibilitychange', visibility); };  }, []);  return { ref, active: visible && !hidden };}export function interactionIcon(on: boolean, reduced: boolean): React.CSSProperties {  return { opacity: on ? 1 : 0, transform: on ? 'none' : 'scale(0.6)', filter: on ? 'blur(0px)' : 'blur(3px)', transition: reduced ? 'none' : `opacity 220ms ${EASE_OUT}, transform 380ms ${EASE_OUT}, filter 220ms ${EASE_OUT}` };}/** Sample recent movement rather than averaging a long drag and losing its release velocity. */export type PointerSample = { x: number; time: number };export function samplePointer(samples: PointerSample[], x: number, time: number) {  samples.push({ x, time });  while (samples.length > 2 && time - samples[0].time > 100) samples.shift();}export function releaseVelocity(samples: PointerSample[], now: number) {  if (samples.length < 2 || now - samples[samples.length - 1].time > 100) return 0;  const first = samples[0], last = samples[samples.length - 1];  return (last.x - first.x) / Math.max(1, last.time - first.time);}/** Smooth Apple/rational rubber-band curve: continuous exponential-like resistance without linear kinks. */export function rubberBand(overshoot: number, dimension = 320, constant = 0.55): number {  const d = dimension || 320;  const abs = Math.abs(overshoot);  return Math.sign(overshoot) * (1 - 1 / ((abs * constant) / d + 1)) * d;}/** Projects resting travel from release velocity (velocity in px/ms; time in seconds). */export function projectInertia(distance: number, velocity: number, time = 0.12): number {  return distance + velocity * 1000 * time;}/** Smooths incoming release velocity toward a boundary so springs don't slam or clip into walls. */export function softenVelocity(velocity: number, distanceToTarget: number, factor = 10): number {  const maxAllowed = Math.abs(distanceToTarget) * factor;  return Math.sign(velocity) * Math.min(Math.abs(velocity), maxAllowed);}/** A damped spring sampled by WAAPI: tuned for organic lightness with a hint of life (3% breath). */export function springFrames(  from: number,  to: number,  velocity = 0,  duration = 480,  config: { omega?: number; damping?: number; steps?: number } = {},) {  const { omega = 16, damping = 0.74, steps = 36 } = config;  const damped = omega * Math.sqrt(Math.max(0.001, 1 - damping * damping));  const displacement = from - to;  const coefficient = (velocity * 1000 + damping * omega * displacement) / damped;  return Array.from({ length: steps + 1 }, (_, i) => {    const t = (i / steps) * (duration / 1000);    const value = to + Math.exp(-damping * omega * t) * (displacement * Math.cos(damped * t) + coefficient * Math.sin(damped * t));    return { value: i === steps ? to : value, offset: i / steps };  });}