feat(web): Your sky closer and fuller: 40% larger, tighter knots, the margins filled (refs #157) 6907a989e82a

        __wbg_getBoundingClientRect_57152b1a20f3de34: function(arg0) {

            const ret = arg0.getBoundingClientRect();

            return ret;

        },

            return ret;

        },

        __wbg_left_e0a244490fe2f293: function(arg0) {

            const ret = arg0.left;

        __wbg_querySelector_ecbc2550705b235f: function() { return handleError(function (arg0, arg1, arg2) {

            const ret = arg0.querySelector(getStringFromWasm0(arg1, arg2));

            return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);

        }, arguments); },

        __wbg_right_1dca6be6342de981: function(arg0) {

            const ret = arg0.right;

            return ret;

        },

        // The content column, which the page marks: clusters go beside it.

        let avoid = self

            .window

            .document()

            .and_then(|d| d.query_selector("[data-backdrop-avoid]").ok().flatten())

            .map(|el| el.get_bounding_client_rect())

            .map(|r| (r.left() as f32, r.right() as f32));

        self.sky.resize(w as f32, h as f32, avoid);

/// The scale of marks and orbits: the sky drawn 40% closer than first

/// built (Andy, 2026-10-13).

const ZOOM: f32 = 1.4;

pub const LIGHT_RADIUS: f32 = 170.0;

const LINK_MAX: f32 = 85.0;

const LABEL_NEAR: f32 = 110.0;

/// A side margin narrower than this holds no clusters: the sky falls back

/// to a ring around the page.

const MIN_MARGIN: f32 = 180.0;

/// The width a cluster gets in a margin's grid.

const CELL: f32 = 260.0;

    /// The page's content column, left and right, in CSS pixels: clusters

    /// go in the margins beside it, where they can be seen.

    avoid: Option<(f32, f32)>,

        let clusters: Vec<Cluster> =

            repos.iter().enumerate().map(|(i, r)| Cluster { name: r.name.clone(), fx: 0.5, fy: 0.5, layer: layer[i] }).collect();

            // Lanes close together: each repository a tight knot.

            let radius = (16.0 + (k % lanes) as f32 * 6.5 + unit(h, 0) * 4.0) * ZOOM;

        let mut sky =

            Sky { clusters, marks, w, h, cursor: None, rested: 0.0, still, avoid: None, parallax: [(0.0, 0.0); 3], link_fade: 0.0 };

        sky.layout();

        sky

    /// The view is now `w` by `h`, its content column between `avoid`'s

    /// left and right.

    pub fn resize(&mut self, w: f32, h: f32, avoid: Option<(f32, f32)>) {

        self.avoid = avoid;

        self.layout();

    }

    /// Place the clusters. In the margins beside the content when both are

    /// wide enough: repositories in the order of their names' hashes, split

    /// between the sides by their widths, each side a staggered grid from

    /// top to bottom, so the sky fills the space the page leaves. Otherwise

    /// a ring around the middle. The same repositories in the same view

    /// always land in the same places.

    fn layout(&mut self) {

        let n = self.clusters.len();

        let mut order: Vec<usize> = (0..n).collect();

        order.sort_by_key(|&i| hash(&self.clusters[i].name));

        let margins = self.avoid.and_then(|(x0, x1)| {

            let (l, r) = (x0.max(0.0), (self.w - x1).max(0.0));

            (l >= MIN_MARGIN && r >= MIN_MARGIN).then_some((l, r, x1))

        });

        match margins {

            Some((l, r, x1)) => {

                let left = (((n as f32) * l / (l + r)).round() as usize).min(n);

                let (a, b) = order.split_at(left);

                self.grid(a, 0.0, l);

                self.grid(b, x1, self.w);

            }

            None => {

                for c in &mut self.clusters {

                    let h = hash(&c.name);

                    let a = unit(h, 0) * TAU;

                    let d = 0.25 + 0.3 * unit(h, 16).sqrt();

                    c.fx = (0.5 + d * a.cos()).clamp(0.03, 0.97);

                    c.fy = (0.5 + 0.9 * d * a.sin()).clamp(0.05, 0.95);

                }

            }

        }

    /// Lay `ids` out in a staggered grid between `x0` and `x1`.

    fn grid(&mut self, ids: &[usize], x0: f32, x1: f32) {

        if ids.is_empty() || self.w <= 0.0 || self.h <= 0.0 {

            return;

        }

        let (top, bottom) = (self.h * 0.1, self.h * 0.97);

        let width = x1 - x0;

        let cols = ((width / CELL) as usize).clamp(1, 3);

        let rows = ids.len().div_ceil(cols);

        let (cw, ch) = (width / cols as f32, (bottom - top) / rows as f32);

        for (j, &i) in ids.iter().enumerate() {

            let (col, row) = (j % cols, j / cols);

            let h = hash(&self.clusters[i].name);

            let stagger = if cols > 1 && row % 2 == 1 { cw * 0.25 } else { 0.0 };

            let cx = x0 + (col as f32 + 0.5) * cw + stagger + (unit(h, 0) - 0.5) * 0.3 * cw;

            let cy = top + (row as f32 + 0.5) * ch + (unit(h, 16) - 0.5) * 0.3 * ch;

            self.clusters[i].fx = cx.clamp(x0 + 24.0, x1 - 24.0) / self.w;

            self.clusters[i].fy = cy / self.h;

        }

    }

            let size = m.kind.size() * ZOOM * (1.0 + 0.35 * m.lit);

    }

    #[test]

    fn clusters_fill_the_margins_beside_the_content() {

        let repos: Vec<Repo> = (0..17).map(|i| Repo { name: format!("owner/repo{i}") }).collect();

        let mut s = Sky::new(&repos, &[], 2560.0, 1270.0, false);

        s.resize(2560.0, 1270.0, Some((707.0, 1838.0)));

        let xs: Vec<f32> = (0..17).map(|i| s.core(i).0).collect();

        assert!(xs.iter().all(|&x| x < 707.0 || x > 1838.0), "none behind the content: {xs:?}");

        let left = xs.iter().filter(|&&x| x < 707.0).count();

        assert!((7..=10).contains(&left), "both sides used: {left} on the left");

        let ys: Vec<f32> = (0..17).map(|i| s.core(i).1).collect();

        assert!(ys.iter().any(|&y| y < 400.0) && ys.iter().any(|&y| y > 900.0), "top to bottom: {ys:?}");

        // The same view lays the same sky out.

        let mut again = Sky::new(&repos, &[], 2560.0, 1270.0, false);

        again.resize(2560.0, 1270.0, Some((707.0, 1838.0)));

        assert_eq!(xs, (0..17).map(|i| again.core(i).0).collect::<Vec<_>>());

        // Narrow margins: back to the ring.

        s.resize(1200.0, 800.0, Some((100.0, 1100.0)));

        assert!((0..17).any(|i| (s.core(i).0 - 600.0).abs() < 400.0));

- Each repository is a cluster. The clusters fill the margins beside the

  content column, which the page marks with `data-backdrop-avoid`: in the

  order of their names' hashes, split between the two sides by their

  widths, each side a staggered grid from top to bottom. The same

  repositories in the same window always land in the same places. Where

  a margin is under 180 px, they sit on a ring around the page instead.

- Marks and orbits are drawn at 1.4 times their first size, with orbit

  lanes close together, so each repository is a tight knot (Andy,

  2026-10-13).

<div class="side-layout rev dash" data-backdrop-avoid>