@1agh/maude 0.19.1 → 0.20.0

package/plugins/design/dev-server/dist/runtime/motion.js

@@ -0,0 +1,165 @@
+var __defProp = Object.defineProperty;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+
+// ../../../node_modules/.pnpm/motion@11.18.2_react-dom@19.2.6_react@19.2.6__react@19.2.6/node_modules/motion/dist/es/motion/lib/index.mjs
+var exports_lib = {};
+__export(exports_lib, {
+  wrap: () => wrap,
+  transform: () => transform,
+  time: () => time,
+  sync: () => sync,
+  steps: () => steps,
+  stagger: () => stagger,
+  spring: () => spring,
+  scrollInfo: () => scrollInfo,
+  scroll: () => scroll,
+  reverseEasing: () => reverseEasing,
+  progress: () => progress,
+  pipe: () => pipe,
+  noop: () => noop,
+  motionValue: () => motionValue,
+  mix: () => mix,
+  mirrorEasing: () => mirrorEasing,
+  keyframes: () => keyframes,
+  isDragActive: () => isDragActive,
+  invariant: () => invariant,
+  interpolate: () => interpolate,
+  inertia: () => inertia,
+  inView: () => inView,
+  frameSteps: () => frameSteps,
+  frameData: () => frameData,
+  frame: () => frame,
+  easeOut: () => easeOut,
+  easeInOut: () => easeInOut,
+  easeIn: () => easeIn,
+  distance2D: () => distance2D,
+  distance: () => distance,
+  delay: () => delayInSeconds,
+  cubicBezier: () => cubicBezier,
+  createScopedAnimate: () => createScopedAnimate,
+  clamp: () => clamp,
+  circOut: () => circOut,
+  circInOut: () => circInOut,
+  circIn: () => circIn,
+  cancelSync: () => cancelSync,
+  cancelFrame: () => cancelFrame,
+  backOut: () => backOut,
+  backInOut: () => backInOut,
+  backIn: () => backIn,
+  anticipate: () => anticipate,
+  animateMini: () => animateMini,
+  animate: () => animate,
+  MotionValue: () => MotionValue
+});
+
+// synth:/home/runner/work/maude/maude/plugins/design/dev-server/.runtime-bundle-motion-entry.tsx
+var {
+  MotionValue: MotionValue2,
+  animate: animate2,
+  animateMini: animateMini2,
+  anticipate: anticipate2,
+  backIn: backIn2,
+  backInOut: backInOut2,
+  backOut: backOut2,
+  cancelFrame: cancelFrame2,
+  cancelSync: cancelSync2,
+  circIn: circIn2,
+  circInOut: circInOut2,
+  circOut: circOut2,
+  clamp: clamp2,
+  createScopedAnimate: createScopedAnimate2,
+  cubicBezier: cubicBezier2,
+  delay,
+  distance: distance2,
+  distance2D: distance2D2,
+  easeIn: easeIn2,
+  easeInOut: easeInOut2,
+  easeOut: easeOut2,
+  frame: frame2,
+  frameData: frameData2,
+  frameSteps: frameSteps2,
+  inView: inView2,
+  inertia: inertia2,
+  interpolate: interpolate2,
+  invariant: invariant2,
+  isDragActive: isDragActive2,
+  keyframes: keyframes2,
+  mirrorEasing: mirrorEasing2,
+  mix: mix2,
+  motionValue: motionValue2,
+  noop: noop2,
+  pipe: pipe2,
+  progress: progress2,
+  reverseEasing: reverseEasing2,
+  scroll: scroll2,
+  scrollInfo: scrollInfo2,
+  spring: spring2,
+  stagger: stagger2,
+  steps: steps2,
+  sync: sync2,
+  time: time2,
+  transform: transform2,
+  wrap: wrap2
+} = exports_lib;
+var __runtime_bundle_motion_entry_default = exports_lib;
+export {
+  wrap2 as wrap,
+  transform2 as transform,
+  time2 as time,
+  sync2 as sync,
+  steps2 as steps,
+  stagger2 as stagger,
+  spring2 as spring,
+  scrollInfo2 as scrollInfo,
+  scroll2 as scroll,
+  reverseEasing2 as reverseEasing,
+  progress2 as progress,
+  pipe2 as pipe,
+  noop2 as noop,
+  motionValue2 as motionValue,
+  mix2 as mix,
+  mirrorEasing2 as mirrorEasing,
+  keyframes2 as keyframes,
+  isDragActive2 as isDragActive,
+  invariant2 as invariant,
+  interpolate2 as interpolate,
+  inertia2 as inertia,
+  inView2 as inView,
+  frameSteps2 as frameSteps,
+  frameData2 as frameData,
+  frame2 as frame,
+  easeOut2 as easeOut,
+  easeInOut2 as easeInOut,
+  easeIn2 as easeIn,
+  distance2D2 as distance2D,
+  distance2 as distance,
+  delay,
+  __runtime_bundle_motion_entry_default as default,
+  cubicBezier2 as cubicBezier,
+  createScopedAnimate2 as createScopedAnimate,
+  clamp2 as clamp,
+  circOut2 as circOut,
+  circInOut2 as circInOut,
+  circIn2 as circIn,
+  cancelSync2 as cancelSync,
+  cancelFrame2 as cancelFrame,
+  backOut2 as backOut,
+  backInOut2 as backInOut,
+  backIn2 as backIn,
+  anticipate2 as anticipate,
+  animateMini2 as animateMini,
+  animate2 as animate,
+  MotionValue2 as MotionValue
+};

package/plugins/design/dev-server/dist/runtime/motion_react.js

@@ -0,0 +1,409 @@
+var __defProp = Object.defineProperty;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+
+// ../../../node_modules/.pnpm/motion@11.18.2_react-dom@19.2.6_react@19.2.6__react@19.2.6/node_modules/motion/dist/es/motion/lib/react.mjs
+var exports_react = {};
+__export(exports_react, {
+  wrap: () => wrap,
+  visualElementStore: () => visualElementStore,
+  useWillChange: () => useWillChange,
+  useViewportScroll: () => useViewportScroll,
+  useVelocity: () => useVelocity,
+  useUnmountEffect: () => useUnmountEffect,
+  useTransform: () => useTransform,
+  useTime: () => useTime,
+  useSpring: () => useSpring,
+  useScroll: () => useScroll,
+  useResetProjection: () => useResetProjection,
+  useReducedMotionConfig: () => useReducedMotionConfig,
+  useReducedMotion: () => useReducedMotion,
+  usePresence: () => usePresence,
+  useMotionValueEvent: () => useMotionValueEvent,
+  useMotionValue: () => useMotionValue,
+  useMotionTemplate: () => useMotionTemplate,
+  useIsomorphicLayoutEffect: () => useIsomorphicLayoutEffect,
+  useIsPresent: () => useIsPresent,
+  useInstantTransition: () => useInstantTransition,
+  useInstantLayoutTransition: () => useInstantLayoutTransition,
+  useInView: () => useInView,
+  useForceUpdate: () => useForceUpdate,
+  useElementScroll: () => useElementScroll,
+  useDragControls: () => useDragControls,
+  useDomEvent: () => useDomEvent,
+  useDeprecatedInvertedScale: () => useInvertedScale,
+  useDeprecatedAnimatedState: () => useAnimatedState,
+  useCycle: () => useCycle,
+  useAnimationFrame: () => useAnimationFrame,
+  useAnimationControls: () => useAnimationControls,
+  useAnimation: () => useAnimation,
+  useAnimateMini: () => useAnimateMini,
+  useAnimate: () => useAnimate,
+  unwrapMotionComponent: () => unwrapMotionComponent,
+  transform: () => transform,
+  time: () => time,
+  sync: () => sync,
+  steps: () => steps,
+  startOptimizedAppearAnimation: () => startOptimizedAppearAnimation,
+  stagger: () => stagger,
+  spring: () => spring,
+  scrollInfo: () => scrollInfo,
+  scroll: () => scroll,
+  reverseEasing: () => reverseEasing,
+  resolveMotionValue: () => resolveMotionValue,
+  px: () => px,
+  progress: () => progress,
+  pipe: () => pipe,
+  optimizedAppearDataAttribute: () => optimizedAppearDataAttribute,
+  noop: () => noop,
+  motionValue: () => motionValue,
+  motion: () => motion,
+  mix: () => mix,
+  mirrorEasing: () => mirrorEasing,
+  makeUseVisualState: () => makeUseVisualState,
+  m: () => m,
+  keyframes: () => keyframes,
+  isValidMotionProp: () => isValidMotionProp,
+  isMotionValue: () => isMotionValue,
+  isMotionComponent: () => isMotionComponent,
+  isDragActive: () => isDragActive,
+  isBrowser: () => isBrowser,
+  invariant: () => invariant,
+  interpolate: () => interpolate,
+  inertia: () => inertia,
+  inView: () => inView,
+  frameSteps: () => frameSteps,
+  frameData: () => frameData,
+  frame: () => frame,
+  findSpring: () => findSpring,
+  filterProps: () => filterProps,
+  easeOut: () => easeOut,
+  easeInOut: () => easeInOut,
+  easeIn: () => easeIn,
+  domMin: () => domMin,
+  domMax: () => domMax,
+  domAnimation: () => domAnimation,
+  distance2D: () => distance2D,
+  distance: () => distance,
+  disableInstantTransitions: () => disableInstantTransitions,
+  delay: () => delay,
+  cubicBezier: () => cubicBezier,
+  createScopedAnimate: () => createScopedAnimate,
+  createRendererMotionComponent: () => createRendererMotionComponent,
+  createBox: () => createBox,
+  complex: () => complex,
+  color: () => color,
+  clamp: () => clamp,
+  circOut: () => circOut,
+  circInOut: () => circInOut,
+  circIn: () => circIn,
+  cancelSync: () => cancelSync,
+  cancelFrame: () => cancelFrame,
+  calcLength: () => calcLength,
+  buildTransform: () => buildTransform,
+  backOut: () => backOut,
+  backInOut: () => backInOut,
+  backIn: () => backIn,
+  anticipate: () => anticipate,
+  animations: () => animations,
+  animationControls: () => animationControls,
+  animateVisualElement: () => animateVisualElement,
+  animateValue: () => animateValue,
+  animateMini: () => animateMini,
+  animate: () => animate,
+  addScaleCorrector: () => addScaleCorrector,
+  addPointerInfo: () => addPointerInfo,
+  addPointerEvent: () => addPointerEvent,
+  VisualElement: () => VisualElement,
+  SwitchLayoutGroupContext: () => SwitchLayoutGroupContext,
+  Reorder: () => namespace,
+  PresenceContext: () => PresenceContext,
+  MotionValue: () => MotionValue,
+  MotionGlobalConfig: () => MotionGlobalConfig,
+  MotionContext: () => MotionContext,
+  MotionConfigContext: () => MotionConfigContext,
+  MotionConfig: () => MotionConfig,
+  LazyMotion: () => LazyMotion,
+  LayoutGroupContext: () => LayoutGroupContext,
+  LayoutGroup: () => LayoutGroup,
+  FlatTree: () => FlatTree,
+  DragControls: () => DragControls,
+  DeprecatedLayoutGroupContext: () => DeprecatedLayoutGroupContext,
+  AnimateSharedLayout: () => AnimateSharedLayout,
+  AnimatePresence: () => AnimatePresence,
+  AcceleratedAnimation: () => AcceleratedAnimation
+});
+"use client";
+
+// synth:/home/runner/work/maude/maude/plugins/design/dev-server/.runtime-bundle-motion_react-entry.tsx
+var {
+  AcceleratedAnimation: AcceleratedAnimation2,
+  AnimatePresence: AnimatePresence2,
+  AnimateSharedLayout: AnimateSharedLayout2,
+  DeprecatedLayoutGroupContext: DeprecatedLayoutGroupContext2,
+  DragControls: DragControls2,
+  FlatTree: FlatTree2,
+  LayoutGroup: LayoutGroup2,
+  LayoutGroupContext: LayoutGroupContext2,
+  LazyMotion: LazyMotion2,
+  MotionConfig: MotionConfig2,
+  MotionConfigContext: MotionConfigContext2,
+  MotionContext: MotionContext2,
+  MotionGlobalConfig: MotionGlobalConfig2,
+  MotionValue: MotionValue2,
+  PresenceContext: PresenceContext2,
+  Reorder,
+  SwitchLayoutGroupContext: SwitchLayoutGroupContext2,
+  VisualElement: VisualElement2,
+  addPointerEvent: addPointerEvent2,
+  addPointerInfo: addPointerInfo2,
+  addScaleCorrector: addScaleCorrector2,
+  animate: animate2,
+  animateMini: animateMini2,
+  animateValue: animateValue2,
+  animateVisualElement: animateVisualElement2,
+  animationControls: animationControls2,
+  animations: animations2,
+  anticipate: anticipate2,
+  backIn: backIn2,
+  backInOut: backInOut2,
+  backOut: backOut2,
+  buildTransform: buildTransform2,
+  calcLength: calcLength2,
+  cancelFrame: cancelFrame2,
+  cancelSync: cancelSync2,
+  circIn: circIn2,
+  circInOut: circInOut2,
+  circOut: circOut2,
+  clamp: clamp2,
+  color: color2,
+  complex: complex2,
+  createBox: createBox2,
+  createRendererMotionComponent: createRendererMotionComponent2,
+  createScopedAnimate: createScopedAnimate2,
+  cubicBezier: cubicBezier2,
+  delay: delay2,
+  disableInstantTransitions: disableInstantTransitions2,
+  distance: distance2,
+  distance2D: distance2D2,
+  domAnimation: domAnimation2,
+  domMax: domMax2,
+  domMin: domMin2,
+  easeIn: easeIn2,
+  easeInOut: easeInOut2,
+  easeOut: easeOut2,
+  filterProps: filterProps2,
+  findSpring: findSpring2,
+  frame: frame2,
+  frameData: frameData2,
+  frameSteps: frameSteps2,
+  inView: inView2,
+  inertia: inertia2,
+  interpolate: interpolate2,
+  invariant: invariant2,
+  isBrowser: isBrowser2,
+  isDragActive: isDragActive2,
+  isMotionComponent: isMotionComponent2,
+  isMotionValue: isMotionValue2,
+  isValidMotionProp: isValidMotionProp2,
+  keyframes: keyframes2,
+  m: m2,
+  makeUseVisualState: makeUseVisualState2,
+  mirrorEasing: mirrorEasing2,
+  mix: mix2,
+  motion: motion2,
+  motionValue: motionValue2,
+  noop: noop2,
+  optimizedAppearDataAttribute: optimizedAppearDataAttribute2,
+  pipe: pipe2,
+  progress: progress2,
+  px: px2,
+  resolveMotionValue: resolveMotionValue2,
+  reverseEasing: reverseEasing2,
+  scroll: scroll2,
+  scrollInfo: scrollInfo2,
+  spring: spring2,
+  stagger: stagger2,
+  startOptimizedAppearAnimation: startOptimizedAppearAnimation2,
+  steps: steps2,
+  sync: sync2,
+  time: time2,
+  transform: transform2,
+  unwrapMotionComponent: unwrapMotionComponent2,
+  useAnimate: useAnimate2,
+  useAnimateMini: useAnimateMini2,
+  useAnimation: useAnimation2,
+  useAnimationControls: useAnimationControls2,
+  useAnimationFrame: useAnimationFrame2,
+  useCycle: useCycle2,
+  useDeprecatedAnimatedState,
+  useDeprecatedInvertedScale,
+  useDomEvent: useDomEvent2,
+  useDragControls: useDragControls2,
+  useElementScroll: useElementScroll2,
+  useForceUpdate: useForceUpdate2,
+  useInView: useInView2,
+  useInstantLayoutTransition: useInstantLayoutTransition2,
+  useInstantTransition: useInstantTransition2,
+  useIsPresent: useIsPresent2,
+  useIsomorphicLayoutEffect: useIsomorphicLayoutEffect2,
+  useMotionTemplate: useMotionTemplate2,
+  useMotionValue: useMotionValue2,
+  useMotionValueEvent: useMotionValueEvent2,
+  usePresence: usePresence2,
+  useReducedMotion: useReducedMotion2,
+  useReducedMotionConfig: useReducedMotionConfig2,
+  useResetProjection: useResetProjection2,
+  useScroll: useScroll2,
+  useSpring: useSpring2,
+  useTime: useTime2,
+  useTransform: useTransform2,
+  useUnmountEffect: useUnmountEffect2,
+  useVelocity: useVelocity2,
+  useViewportScroll: useViewportScroll2,
+  useWillChange: useWillChange2,
+  visualElementStore: visualElementStore2,
+  wrap: wrap2
+} = exports_react;
+var __runtime_bundle_motion_react_entry_default = exports_react;
+export {
+  wrap2 as wrap,
+  visualElementStore2 as visualElementStore,
+  useWillChange2 as useWillChange,
+  useViewportScroll2 as useViewportScroll,
+  useVelocity2 as useVelocity,
+  useUnmountEffect2 as useUnmountEffect,
+  useTransform2 as useTransform,
+  useTime2 as useTime,
+  useSpring2 as useSpring,
+  useScroll2 as useScroll,
+  useResetProjection2 as useResetProjection,
+  useReducedMotionConfig2 as useReducedMotionConfig,
+  useReducedMotion2 as useReducedMotion,
+  usePresence2 as usePresence,
+  useMotionValueEvent2 as useMotionValueEvent,
+  useMotionValue2 as useMotionValue,
+  useMotionTemplate2 as useMotionTemplate,
+  useIsomorphicLayoutEffect2 as useIsomorphicLayoutEffect,
+  useIsPresent2 as useIsPresent,
+  useInstantTransition2 as useInstantTransition,
+  useInstantLayoutTransition2 as useInstantLayoutTransition,
+  useInView2 as useInView,
+  useForceUpdate2 as useForceUpdate,
+  useElementScroll2 as useElementScroll,
+  useDragControls2 as useDragControls,
+  useDomEvent2 as useDomEvent,
+  useDeprecatedInvertedScale,
+  useDeprecatedAnimatedState,
+  useCycle2 as useCycle,
+  useAnimationFrame2 as useAnimationFrame,
+  useAnimationControls2 as useAnimationControls,
+  useAnimation2 as useAnimation,
+  useAnimateMini2 as useAnimateMini,
+  useAnimate2 as useAnimate,
+  unwrapMotionComponent2 as unwrapMotionComponent,
+  transform2 as transform,
+  time2 as time,
+  sync2 as sync,
+  steps2 as steps,
+  startOptimizedAppearAnimation2 as startOptimizedAppearAnimation,
+  stagger2 as stagger,
+  spring2 as spring,
+  scrollInfo2 as scrollInfo,
+  scroll2 as scroll,
+  reverseEasing2 as reverseEasing,
+  resolveMotionValue2 as resolveMotionValue,
+  px2 as px,
+  progress2 as progress,
+  pipe2 as pipe,
+  optimizedAppearDataAttribute2 as optimizedAppearDataAttribute,
+  noop2 as noop,
+  motionValue2 as motionValue,
+  motion2 as motion,
+  mix2 as mix,
+  mirrorEasing2 as mirrorEasing,
+  makeUseVisualState2 as makeUseVisualState,
+  m2 as m,
+  keyframes2 as keyframes,
+  isValidMotionProp2 as isValidMotionProp,
+  isMotionValue2 as isMotionValue,
+  isMotionComponent2 as isMotionComponent,
+  isDragActive2 as isDragActive,
+  isBrowser2 as isBrowser,
+  invariant2 as invariant,
+  interpolate2 as interpolate,
+  inertia2 as inertia,
+  inView2 as inView,
+  frameSteps2 as frameSteps,
+  frameData2 as frameData,
+  frame2 as frame,
+  findSpring2 as findSpring,
+  filterProps2 as filterProps,
+  easeOut2 as easeOut,
+  easeInOut2 as easeInOut,
+  easeIn2 as easeIn,
+  domMin2 as domMin,
+  domMax2 as domMax,
+  domAnimation2 as domAnimation,
+  distance2D2 as distance2D,
+  distance2 as distance,
+  disableInstantTransitions2 as disableInstantTransitions,
+  delay2 as delay,
+  __runtime_bundle_motion_react_entry_default as default,
+  cubicBezier2 as cubicBezier,
+  createScopedAnimate2 as createScopedAnimate,
+  createRendererMotionComponent2 as createRendererMotionComponent,
+  createBox2 as createBox,
+  complex2 as complex,
+  color2 as color,
+  clamp2 as clamp,
+  circOut2 as circOut,
+  circInOut2 as circInOut,
+  circIn2 as circIn,
+  cancelSync2 as cancelSync,
+  cancelFrame2 as cancelFrame,
+  calcLength2 as calcLength,
+  buildTransform2 as buildTransform,
+  backOut2 as backOut,
+  backInOut2 as backInOut,
+  backIn2 as backIn,
+  anticipate2 as anticipate,
+  animations2 as animations,
+  animationControls2 as animationControls,
+  animateVisualElement2 as animateVisualElement,
+  animateValue2 as animateValue,
+  animateMini2 as animateMini,
+  animate2 as animate,
+  addScaleCorrector2 as addScaleCorrector,
+  addPointerInfo2 as addPointerInfo,
+  addPointerEvent2 as addPointerEvent,
+  VisualElement2 as VisualElement,
+  SwitchLayoutGroupContext2 as SwitchLayoutGroupContext,
+  Reorder,
+  PresenceContext2 as PresenceContext,
+  MotionValue2 as MotionValue,
+  MotionGlobalConfig2 as MotionGlobalConfig,
+  MotionContext2 as MotionContext,
+  MotionConfigContext2 as MotionConfigContext,
+  MotionConfig2 as MotionConfig,
+  LazyMotion2 as LazyMotion,
+  LayoutGroupContext2 as LayoutGroupContext,
+  LayoutGroup2 as LayoutGroup,
+  FlatTree2 as FlatTree,
+  DragControls2 as DragControls,
+  DeprecatedLayoutGroupContext2 as DeprecatedLayoutGroupContext,
+  AnimateSharedLayout2 as AnimateSharedLayout,
+  AnimatePresence2 as AnimatePresence,
+  AcceleratedAnimation2 as AcceleratedAnimation
+};

package/plugins/design/dev-server/equal-spacing-detector.ts

@@ -0,0 +1,98 @@
+/**
+ * @file       equal-spacing-detector.ts — T27 (Wave 3)
+ * @scope      plugins/design/dev-server/equal-spacing-detector.ts
+ * @purpose    Pure detector for Figma "Smart Selection" pink-dot affordance
+ *             (Rasmus Andersson 2018). Given 3+ rects on a single axis,
+ *             returns the equal gap + the screen-coord midpoints between
+ *             adjacent pairs IF all pairwise gaps are within `tolerancePx`
+ *             of each other. Returns `null` when the rects are not equally
+ *             distributed.
+ *
+ *             Pure / DOM-free / framework-free — same convention as
+ *             `computeSnap` in `use-snap-guides.tsx`. The overlay layer
+ *             consumes the result and paints the pink dots.
+ *
+ *             Coordinate space is the caller's choice — pass screen-space
+ *             rects for live overlay rendering, or world-space rects for
+ *             distribute-command verification. The math is uniform either
+ *             way; only the unit of `tolerancePx` differs.
+ */
+
+import type { Rect } from './use-snap-guides.tsx';
+
+export type SpacingAxis = 'x' | 'y';
+
+export interface EqualSpacingResult {
+  axis: SpacingAxis;
+  /** The gap measured between adjacent rects (post-sort by leading edge).
+   *  Caller renders this in the distance pill above each pink dot. */
+  gapPx: number;
+  /** Midpoint coords between consecutive rects. Length = rects.length - 1.
+   *  Each entry is in caller's coord space; renderers anchor pink dots here. */
+  midpoints: Array<{ x: number; y: number }>;
+}
+
+interface DetectOptions {
+  /** How close gaps must be to count as "equal", in caller's unit (default 1). */
+  tolerancePx?: number;
+}
+
+/**
+ * Detect equal spacing along one axis. Returns `null` when:
+ *   - fewer than 3 rects (2 rects trivially have "equal" spacing — undefined).
+ *   - any pairwise gap differs from the median by more than `tolerancePx`.
+ *   - rects overlap on the spacing axis (gap < 0 anywhere).
+ *
+ * The midpoint y (for axis='x') or x (for axis='y') is the average of the
+ * adjacent rects' center on the perpendicular axis — this places the pink
+ * dot vertically centered between the two siblings, which is where the
+ * distance pill anchors above.
+ */
+export function detectEqualSpacing(
+  rects: Rect[],
+  axis: SpacingAxis,
+  opts: DetectOptions = {}
+): EqualSpacingResult | null {
+  if (rects.length < 3) return null;
+  const tol = opts.tolerancePx ?? 1;
+
+  // Sort by leading edge on the spacing axis.
+  const sorted = [...rects].sort((a, b) => (axis === 'x' ? a.x - b.x : a.y - b.y));
+
+  // Compute pairwise gaps + midpoints.
+  const gaps: number[] = [];
+  const midpoints: Array<{ x: number; y: number }> = [];
+  for (let i = 1; i < sorted.length; i++) {
+    const prev = sorted[i - 1];
+    const cur = sorted[i];
+    if (!prev || !cur) return null;
+    if (axis === 'x') {
+      const gap = cur.x - (prev.x + prev.w);
+      if (gap < 0) return null; // overlap; not a distributed set
+      gaps.push(gap);
+      midpoints.push({
+        x: prev.x + prev.w + gap / 2,
+        y: (prev.y + prev.h / 2 + (cur.y + cur.h / 2)) / 2,
+      });
+    } else {
+      const gap = cur.y - (prev.y + prev.h);
+      if (gap < 0) return null;
+      gaps.push(gap);
+      midpoints.push({
+        x: (prev.x + prev.w / 2 + (cur.x + cur.w / 2)) / 2,
+        y: prev.y + prev.h + gap / 2,
+      });
+    }
+  }
+
+  // All gaps must be within tolerance of each other. Use the median as anchor
+  // to be robust against a single outlier — though if any gap is outside the
+  // band we return null, so median vs mean is academic here.
+  const sortedGaps = [...gaps].sort((a, b) => a - b);
+  const median = sortedGaps[Math.floor(sortedGaps.length / 2)] ?? 0;
+  for (const g of gaps) {
+    if (Math.abs(g - median) > tol) return null;
+  }
+
+  return { axis, gapPx: median, midpoints };
+}