cursedbelt 5.96.1 → 5.97.0

package/src/react/lib/paneReach.spec.ts

@@ -0,0 +1,58 @@
+import { describe, expect, test } from 'bun:test';
+import { reachSize, stepSize } from './paneReach.js';
+
+// The owner, 2026-10-27: every divider goes as far as the hand takes it, shutting a pane included.
+describe('reachSize — where a pointer drag lands', () => {
+  test('has no maximum: the first pane can take the whole axis', () => {
+    expect(reachSize(1000, 160, 1000)).toBe(1000);
+    expect(reachSize(1400, 160, 1000)).toBe(1000);
+    expect(reachSize(0.99, 0.12, 1)).toBe(1);
+  });
+
+  test('shuts a pane dragged below half its minimum, either side of the seam', () => {
+    expect(reachSize(79, 160, 1000)).toBe(0);
+    expect(reachSize(-40, 160, 1000)).toBe(0);
+    expect(reachSize(921, 160, 1000)).toBe(1000);
+  });
+
+  test('holds at the minimum between half and all of it, so no pane is a sliver', () => {
+    expect(reachSize(100, 160, 1000)).toBe(160);
+    expect(reachSize(900, 160, 1000)).toBe(840);
+  });
+
+  test('passes every size between the two minimums through untouched', () => {
+    expect(reachSize(500, 160, 1000)).toBe(500);
+    expect(reachSize(160, 160, 1000)).toBe(160);
+  });
+
+  test('a minimum larger than half the axis shrinks to half, so both panes still fit', () => {
+    expect(reachSize(300, 800, 1000)).toBe(500);
+  });
+
+  test('a zero-width axis gives nothing rather than NaN or Infinity', () => {
+    expect(reachSize(10, 160, 0)).toBe(0);
+    expect(reachSize(Number.NaN, 160, 1000)).toBe(0);
+  });
+});
+
+describe('stepSize — where an arrow key lands', () => {
+  test('a step that would cross the minimum stops on it, and the next one shuts', () => {
+    expect(stepSize(170, -16, 160, 1000)).toBe(160);
+    expect(stepSize(160, -16, 160, 1000)).toBe(0);
+  });
+
+  test('the first step out of shut opens at the minimum, not a sliver', () => {
+    expect(stepSize(0, 16, 160, 1000)).toBe(160);
+  });
+
+  test('the far end shuts the other pane the same way, and opens it the same way', () => {
+    expect(stepSize(830, 16, 160, 1000)).toBe(840);
+    expect(stepSize(840, 16, 160, 1000)).toBe(1000);
+    expect(stepSize(1000, -16, 160, 1000)).toBe(840);
+  });
+
+  test('works in shares as well as pixels, through float noise', () => {
+    expect(stepSize(0.12000000001, -0.02, 0.12, 1)).toBe(0);
+    expect(stepSize(0.5, 0.02, 0.12, 1)).toBeCloseTo(0.52);
+  });
+});

package/src/react/lib/paneReach.ts

@@ -0,0 +1,65 @@
+/**
+ * How far a divider may be dragged — the ONE rule every resizable split in cursedbelt obeys.
+ *
+ * The owner, 2026-10-27: *"For all dividers … that I can drag to size the panes, let me drag them
+ * as far as I want including shutting a pane completely … I don't want any panes to block me."*
+ * Station's Queue was the worked example: its task list stopped at 36% of the page, so the titles
+ * it was opened to read stayed cut off however hard the divider was pulled.
+ *
+ * So a pane has no MAXIMUM, ever — a pane grows until its neighbor is shut — and its minimum is
+ * not a wall but a snap, VS Code's sash and `react-resizable-panels`' collapsible panel alike:
+ *
+ *   - dragged below HALF its minimum, a pane SHUTS (size 0);
+ *   - between half and the whole minimum it HOLDS at the minimum, so a pane is never drawn as an
+ *     unreadable sliver and a shut is a deliberate pull, not a twitch;
+ *   - the same at the far end, for the pane on the other side of the seam.
+ *
+ * A shut pane opens again the way it closed: drag the seam back out (it is still there, at the
+ * edge), or step it with an arrow key. `PanelGrid`/`SplitPane` get the same rule from the library
+ * (every leaf is `collapsible`); `PaneSplit` and `useRailResize` draw their own seams and call
+ * these. An app that draws a seam of its own calls them too — guardrails' `no-hand-rolled-divider`
+ * refuses one that does not.
+ *
+ * Units are the caller's — pixels or a share of 1 — as long as all three agree.
+ */
+
+/** Below this share of `total`, two sizes are the same size (a float's last bits are not a gap). */
+const EPSILON = 1e-4;
+
+/** The snap a pane gets, never more than half the axis — two minimums must fit side by side. */
+function snapOf(min: number, total: number): number {
+  return Math.max(0, Math.min(min, total / 2));
+}
+
+/**
+ * Where a POINTER drag lands: the size the pointer asks for, with the snap applied at both ends.
+ * `size` is the first pane's (the one before the seam); the second pane is `total - size`.
+ */
+export function reachSize(size: number, min: number, total: number): number {
+  if (!(total > 0) || !Number.isFinite(size)) return 0;
+  const snap = snapOf(min, total);
+  if (size < snap / 2) return 0;
+  if (size < snap) return snap;
+  if (size > total - snap / 2) return total;
+  if (size > total - snap) return total - snap;
+  return size;
+}
+
+/**
+ * Where a KEYBOARD step lands. A step that would cross a minimum stops ON it, and the next step
+ * the same way shuts the pane — so every size, including shut, is reachable from the keys, and
+ * a shut pane's first step out opens it at its minimum, not a sliver.
+ */
+export function stepSize(size: number, delta: number, min: number, total: number): number {
+  if (!(total > 0) || !Number.isFinite(size) || delta === 0) return size;
+  const snap = snapOf(min, total);
+  const near = (a: number, b: number) => Math.abs(a - b) <= total * EPSILON;
+  if (delta < 0) {
+    if (near(size, total)) return total - snap;
+    if (size <= snap || near(size, snap)) return 0;
+    return Math.max(snap, size + delta);
+  }
+  if (near(size, 0)) return snap;
+  if (size >= total - snap || near(size, total - snap)) return total;
+  return Math.min(total - snap, size + delta);
+}

package/src/react/master-detail/MasterDetail.tsx

@@ -85,13 +85,17 @@ export interface MasterDetailProps {
 	/** Distinct per page — SplitPane persists pane widths under it. */
 	storageKey?: string;
 	/**
-	 * The LIST pane's share of the width — default 30% between 16rem and 44%. A page whose detail is
+	 * The LIST pane's share of the width — default 30%, snapping at 16rem. A page whose detail is
 	 * the thing being read (a task's text, an app's charts) gives the list less: station's Queue at
 	 * 1440 drew a 30% list of one-line titles beside a detail pane of four facts, so the text the
 	 * owner opened the page for had nowhere to go (forge task station-evolution, 2026-10-20). Any
-	 * CSS length or percentage; the reader can still drag the divider inside `min`/`max`.
+	 * CSS length or percentage.
+	 *
+	 * 🔴 There is no `max`: the reader drags the divider as far as they like, shutting either pane
+	 * (the owner, 2026-10-27 — station's Queue capped its list at 36% and cut its titles off). `min`
+	 * is the snap `SplitPane` gives it, not a floor.
 	 */
-	masterSize?: { default?: string; min?: string; max?: string };
+	masterSize?: { default?: string; min?: string };
 	/** Rendered above the filters (a "New…" button, a count, a refresh). */
 	listHeader?: ReactNode;
 	className?: string;
@@ -320,8 +324,9 @@ export function MasterDetail({
 				{...(storageKey ? { storageKey } : {})}
 				separatorVariant="line"
 				panels={[
-					{ id: "master", content: list, defaultSize: masterSize?.default ?? "30%", minSize: masterSize?.min ?? "16rem", maxSize: masterSize?.max ?? "44%" },
-					{ id: "detail", content: pane },
+					{ id: "master", content: list, defaultSize: masterSize?.default ?? "30%", minSize: masterSize?.min ?? "16rem" },
+					// The detail snaps too, so the list can take the whole width without a sliver beside it.
+					{ id: "detail", content: pane, minSize: "16rem" },
 				]}
 			/>
 		</div>

package/src/react/media/videoEnhance.ts

@@ -19,7 +19,7 @@
  * ── 🔴 Upscaling is HONEST here, and deliberately modest ───────────────────────────────
  * There is no detail in a video frame that was not decoded, so nothing here can invent any.
  * What upscaling buys is real but narrow: a 300×200 crop of a 4K frame saved at 1× is a tiny
- * picture that every later viewer scales up with nearest-neighbour-ish defaults, whereas
+ * picture that every later viewer scales up with nearest-neighbor-ish defaults, whereas
  * resampling it once, at capture, with `imageSmoothingQuality: 'high'`, produces a smoother
  * enlargement than each viewer would make for itself. So the ceiling is low on purpose — 4×
  * is already past the point of adding anything, and beyond that it is only file size.

package/src/testing/phoneRules.ts

@@ -107,8 +107,8 @@ export function judgePhone(s: PhoneSnapshot, { touch }: JudgePhoneOptions): Desi
   if (!touch) return found;
   for (const f of s.fields.filter((f) => f.size < ZOOM_FLOOR)) push('FRM-11', f.what, `${f.size}px text: iOS zooms the page into a field under ${ZOOM_FLOOR}px`);
   for (const t of s.targets.filter((t) => !t.inline && !t.cut && Math.min(t.w, t.h) < TARGET_FLOOR)) {
-    const neighbour = crowded(t, s.targets);
-    if (neighbour) push('LAY-13', t.what, `${Math.round(t.w)}×${Math.round(t.h)}: under ${TARGET_FLOOR}px and too close to ${neighbour}`);
+    const neighbor = crowded(t, s.targets);
+    if (neighbor) push('LAY-13', t.what, `${Math.round(t.w)}×${Math.round(t.h)}: under ${TARGET_FLOOR}px and too close to ${neighbor}`);
   }
   // The probe steps a pixel at a time from a center that may sit on a half pixel, so a 44px halo can read 43.
   const cramped = s.targets.filter((t) => !t.inline && !t.cut && Math.min(t.w, t.h) < THUMB - 1.5 && Math.min(t.w, t.h) >= TARGET_FLOOR - 0.5);