cursedbelt 5.0.1 → 5.2.0

package/src/react/file-tree/FileTree.tsx

@@ -2121,7 +2121,7 @@ export function FileTree({
         : null;
 
     const rowBody = (
-      // biome-ignore lint/a11y/useFocusableInteractive: it IS focusable — `tabIndex`
+      // It IS focusable — `tabIndex`
       // is set below by the roving-focus rule (one row at 0, the rest at -1).
       <div
         role='treeitem'
@@ -2205,7 +2205,7 @@ export function FileTree({
         {...externalHandlers(node)}
       >
         {row.expandable ? (
-          // biome-ignore lint/a11y/noStaticElementInteractions: a disclosure twisty
+          // A disclosure twisty
           // inside a `treeitem`, which already carries `aria-expanded` — a nested
           // <button> would be a second focus stop announcing the same state twice.
           <span
@@ -2444,7 +2444,7 @@ export function FileTree({
         </div>
       ) : null}
 
-      {/* biome-ignore lint/a11y/noStaticElementInteractions: the blank area under the tree is
+      {/* The blank area under the tree is
           a DROP TARGET, not a control — "get this out of here" is the one gesture with no
           row to aim at. Every move it can express is also on a row's own menu. */}
       <div

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

@@ -0,0 +1,128 @@
+/**
+ * `cursedbelt/react/upload-direct` — the browser half of a resumable upload to binary-server.
+ *
+ * Neither app that carried this module (collections, family) had a test of it, so these pin the
+ * behaviours a 10 GB upload depends on, against a scripted `fetch`: resume skips delivered parts,
+ * parts are PUT with their bytes, a 403 re-mints the token, a 507 is terminal and never retried, a
+ * dropped part is retried, low disk only WARNS, and a lost final response is recovered by asking.
+ */
+import { afterEach, describe, expect, test } from 'bun:test';
+import { chunkCount, fetchSessionState, InsufficientStorageError, type UploadSession, uploadDirect } from './directUpload.js';
+
+const SESSION: UploadSession = {
+  baseUrl: 'https://bs.test',
+  path: 'family/media/abc def',
+  token: 't1',
+  sid: 's',
+  totalChunks: 3,
+  chunkBytes: 4,
+};
+const FILE = new Blob(['aaaabbbbcc'], { type: 'image/jpeg' });
+
+interface Call {
+  method: string;
+  url: URL;
+  body: string | null;
+}
+
+const realFetch = globalThis.fetch;
+afterEach(() => {
+  globalThis.fetch = realFetch;
+});
+
+/** Install a `fetch` that records every call and answers from `answer`. */
+function script(answer: (call: Call) => Response | Promise<Response>): Call[] {
+  const calls: Call[] = [];
+  globalThis.fetch = (async (input: string, init?: RequestInit) => {
+    const body = init?.body instanceof Blob ? await init.body.text() : null;
+    const call = { method: init?.method ?? 'GET', url: new URL(String(input)), body };
+    calls.push(call);
+    return answer(call);
+  }) as unknown as typeof fetch;
+  return calls;
+}
+
+const json = (status: number, body: unknown) => new Response(JSON.stringify(body), { status });
+const status = (received: number[], extra: Record<string, unknown> = {}) => json(200, { received, complete: false, ...extra });
+
+describe('chunkCount and fetchSessionState', () => {
+  test('parts round UP, and an empty file is still one part', () => {
+    expect(chunkCount(10, 4)).toBe(3);
+    expect(chunkCount(8, 4)).toBe(2);
+    expect(chunkCount(0, 4)).toBe(1);
+  });
+
+  test('a status the server cannot answer is a FRESH session, not a failure', async () => {
+    script(() => new Response('nope', { status: 500 }));
+    const state = await fetchSessionState(SESSION);
+    expect([...state.received]).toEqual([]);
+    expect(state.complete).toBe(false);
+  });
+});
+
+describe('uploadDirect', () => {
+  test('resumes: sends only the parts binary-server does not hold, with their bytes, to an encoded path', async () => {
+    const calls = script((c) =>
+      c.method === 'GET' ? status([1]) : json(200, c.url.searchParams.get('ci') === '2' ? { assembled: true, size: 10, checksum: 'h', key: SESSION.path } : {}),
+    );
+    const result = await uploadDirect(FILE, SESSION, { concurrency: 1 });
+    const puts = calls.filter((c) => c.method === 'PUT');
+    expect(puts.map((c) => [c.url.searchParams.get('ci'), c.body])).toEqual([
+      ['0', 'aaaa'],
+      ['2', 'cc'],
+    ]);
+    expect(puts[0]?.url.pathname).toBe('/upload-chunk/family/media/abc%20def');
+    expect(result).toEqual({ key: SESSION.path, size: 10, checksum: 'h' });
+  });
+
+  test('an object already complete sends NOTHING', async () => {
+    const calls = script(() => json(200, { received: [0, 1, 2], complete: true, size: 10, checksum: 'h' }));
+    expect(await uploadDirect(FILE, SESSION)).toEqual({ key: SESSION.path, size: 10, checksum: 'h' });
+    expect(calls.filter((c) => c.method === 'PUT')).toEqual([]);
+  });
+
+  test('a 403 re-mints the token and the retry carries the new one', async () => {
+    let first = true;
+    const calls = script((c) => {
+      if (c.method === 'GET') return status([0, 1]);
+      if (first) {
+        first = false;
+        return new Response('expired', { status: 403 });
+      }
+      return json(200, { assembled: true, size: 10, checksum: null });
+    });
+    await uploadDirect(FILE, SESSION, { refreshToken: async () => 't2', retries: 3 });
+    const puts = calls.filter((c) => c.method === 'PUT').map((c) => c.url.searchParams.get('token'));
+    expect(puts).toEqual(['t1', 't2']);
+  }, 10_000);
+
+  test('🔴 a 507 is TERMINAL — one attempt, a named error, no retry storm against a full disk', async () => {
+    const calls = script((c) => (c.method === 'GET' ? status([0, 1]) : json(507, { freeBytes: 0 })));
+    await expect(uploadDirect(FILE, SESSION, { retries: 5 })).rejects.toBeInstanceOf(InsufficientStorageError);
+    expect(calls.filter((c) => c.method === 'PUT')).toHaveLength(1);
+  });
+
+  test('🔴 low disk only WARNS — the upload still runs (the owner, 2026-08-13)', async () => {
+    const warned: unknown[] = [];
+    script((c) => (c.method === 'GET' ? status([], { freeBytes: 1 }) : json(200, { assembled: c.url.searchParams.get('ci') === '2' })));
+    await uploadDirect(FILE, SESSION, { onLowDisk: (info) => warned.push(info) });
+    expect(warned).toEqual([{ freeBytes: 1, needBytes: 10 }]);
+  });
+
+  test('a lost final response is recovered by ASKING, not by re-sending', async () => {
+    let gets = 0;
+    const calls = script((c) => {
+      if (c.method === 'GET') return ++gets === 1 ? status([0, 1]) : json(200, { received: [0, 1, 2], complete: true, size: 10, checksum: 'z' });
+      return json(200, {}); // the part landed; the assemble result never reached us
+    });
+    expect(await uploadDirect(FILE, SESSION)).toEqual({ key: SESSION.path, size: 10, checksum: 'z' });
+    expect(calls.filter((c) => c.method === 'PUT')).toHaveLength(1);
+  });
+
+  test('progress reaches 1', async () => {
+    const seen: number[] = [];
+    script((c) => (c.method === 'GET' ? status([]) : json(200, { assembled: c.url.searchParams.get('ci') === '2' })));
+    await uploadDirect(FILE, SESSION, { onProgress: (f) => seen.push(f) });
+    expect(seen.at(-1)).toBe(1);
+  });
+});

package/src/react/lib/directUpload.ts

@@ -0,0 +1,334 @@
+/**
+ * `cursedbelt/react/upload-direct` — browser-side resumable upload, straight from the file input
+ * to binary-server.
+ *
+ * Lifted 2026-09-23 (cursedbelt 5.2.0, task 056-343's browser half) from `src/kit/directUpload.ts`,
+ * identical in collections and family. The server half — minting the session — is
+ * `cursedbelt-server/binary-store/upload-session`'s `createUploadSession`.
+ *
+ * 🔴 THIS FILE RUNS IN A BROWSER. It must never import `node:*`, `binaryStore.ts`, or
+ * anything that reaches a private key — see {@link UploadSession}. Keep it dependency-free.
+ *
+ * ## Why the bytes skip the app server
+ *
+ * Every satellite's upload route reads the whole body (`formData()` → `arrayBuffer()`) before
+ * handing it to binary-server, inside a unit capped at `MemoryMax=300M` on a shared t3.micro
+ * that also runs nginx and every other app. That is why the fleet's upload ceiling is 32 MB
+ * and why raising the number was never the fix: a 10 GB video does not fit in the process, in
+ * the nginx body limit, or in the Cloudflare Tunnel's ~100 MB request wall.
+ *
+ * So a large file does not go through the app server at all. The app server mints a session
+ * token naming exactly one destination key; the browser PUTs bounded parts directly to
+ * binary-server, which assembles them; the app server is told afterwards and records the
+ * metadata. No byte of video touches the EC2 box, which is the owner's standing rule for
+ * video (2026-08-12) and also the only shape that survives the memory limit.
+ *
+ * ## What makes it survive 10 GB
+ *
+ * - **Resume.** `GET /upload-chunk` reports which parts already landed, so an upload that
+ *   dies at 90% resumes instead of restarting. That answer comes from the parts on disk, so
+ *   it survives a binary-server restart too.
+ * - **Bounded concurrency.** A few parts in flight keeps a home upstream saturated without
+ *   putting the whole file in memory. Only one part's bytes are ever read at a time per slot.
+ * - **Per-part retry.** A dropped part costs one part, not the upload.
+ * - **Slicing, not reading.** `Blob.slice` is lazy — the 10 GB file is never materialized.
+ */
+
+/** Everything the browser needs to run an upload, minted server-side by `createUploadSession`
+ *  in `cursedbelt-server/binary-store/upload-session`. Contains a capability token scoped to ONE key, and no key
+ *  material — it is safe to hand to the page that will do the uploading. */
+export interface UploadSession {
+	/** binary-server's public base, e.g. `https://binary-server.cursedalchemy.com`. */
+	baseUrl: string;
+	/** App-prefixed destination key, e.g. `family/media/<uuid>`. */
+	path: string;
+	/** Signed token authorizing this session (carries `sid`, `tc` and the source length `sz`). */
+	token: string;
+	/** Chunk session id. */
+	sid: string;
+	/** Total parts the file was split into. */
+	totalChunks: number;
+	/** Bytes per part — must match what the token's `tc` was computed from. */
+	chunkBytes: number;
+}
+
+export interface DirectUploadOptions {
+	/** 0..1, called as parts complete. */
+	onProgress?: (fraction: number, bytesSent: number, totalBytes: number) => void;
+	/** Parts in flight at once. Default 3 — enough to saturate a home upstream, few enough
+	 *  that a failure retries cheaply. */
+	concurrency?: number;
+	/** Attempts per part before giving up. Default 5, with backoff. */
+	retries?: number;
+	/**
+	 * Called once, before any part is sent, when the store reports less free space than this
+	 * upload is likely to need.
+	 *
+	 * 🔴 A WARNING and nothing else — it cannot stop the upload, and there is deliberately no
+	 * way for it to. The owner's instruction (2026-08-13) is that space must never block them:
+	 * *"Remove all blockers for space and only allow warning me. I'll manage space myself
+	 * beyond that."* Returning `false` from here, or throwing, would quietly reinstate exactly
+	 * the blocker that was removed.
+	 */
+	onLowDisk?: (info: { freeBytes: number; needBytes: number }) => void;
+	/** Abort the whole upload (a cancel button, or unmount). */
+	signal?: AbortSignal;
+	/** Re-mint an expired session token mid-upload. A 10 GB upload can outlive any TTL short
+	 *  enough to be safe, so the page supplies a way to ask its own server for a fresh one
+	 *  for the SAME `sid`. Without it, a long upload simply fails on expiry. */
+	refreshToken?: () => Promise<string>;
+}
+
+/** What binary-server reports once the last part lands. */
+export interface DirectUploadResult {
+	key: string;
+	size: number;
+	checksum: string | null;
+}
+
+const sleep = (ms: number): Promise<void> => new Promise((r) => setTimeout(r, ms));
+
+/** Split `[0, total)` into `chunkBytes`-sized part indices. */
+export const chunkCount = (totalBytes: number, chunkBytes: number): number =>
+	Math.max(1, Math.ceil(totalBytes / chunkBytes));
+
+const chunkUrl = (s: UploadSession, token: string, ci: number): string =>
+	`${s.baseUrl}/upload-chunk/${s.path
+		.split("/")
+		.map(encodeURIComponent)
+		.join("/")}?token=${encodeURIComponent(token)}&ci=${ci}`;
+
+const statusUrl = (s: UploadSession, token: string): string =>
+	`${s.baseUrl}/upload-chunk/${s.path
+		.split("/")
+		.map(encodeURIComponent)
+		.join("/")}?token=${encodeURIComponent(token)}`;
+
+/** Which parts binary-server already holds, plus whether the object is already complete.
+ *  A fresh session answers `{ received: [], complete: false }`, so callers need no special
+ *  case for "first attempt". */
+export async function fetchSessionState(
+	session: UploadSession,
+	token = session.token,
+	signal?: AbortSignal,
+): Promise<{
+	received: Set<number>;
+	complete: boolean;
+	size: number | null;
+	checksum: string | null;
+	/** Bytes binary-server still has room for, or null if it could not tell. */
+	freeBytes: number | null;
+}> {
+	const res = await fetch(statusUrl(session, token), { signal });
+	if (!res.ok)
+		return {
+			received: new Set(),
+			complete: false,
+			size: null,
+			checksum: null,
+			freeBytes: null,
+		};
+	const body = (await res.json()) as {
+		received?: number[];
+		complete?: boolean;
+		size?: number | null;
+		checksum?: string | null;
+		freeBytes?: number | null;
+	};
+	return {
+		received: new Set(body.received ?? []),
+		complete: Boolean(body.complete),
+		size: body.size ?? null,
+		checksum: body.checksum ?? null,
+		freeBytes: body.freeBytes ?? null,
+	};
+}
+
+/** Thrown when binary-server has no room for the file. Distinct from a transport failure so a
+ *  UI can say "the server is full" — which is actionable — rather than "upload failed", which
+ *  invites the person to retry forever against a disk that will never have space. */
+export class InsufficientStorageError extends Error {
+	constructor(
+		readonly needBytes: number,
+		readonly freeBytes: number | null,
+		/**
+		 * 🔴 Vestigial since 2026-08-13 and kept only so an older deployed binary-server can
+		 * still be understood: THIS service no longer refuses an upload for disk space at all,
+		 * so nothing here should be producing an overridable refusal any more. If you see one,
+		 * the origin is running a build from before that change.
+		 */
+		readonly overridable = false,
+	) {
+		super(
+			freeBytes === null
+				? "binary-server is out of space for this upload"
+				: `binary-server has ${(freeBytes / 1024 ** 3).toFixed(1)} GB free, which is not enough for a ${(needBytes / 1024 ** 3).toFixed(1)} GB upload`,
+		);
+		this.name = "InsufficientStorageError";
+	}
+}
+
+/**
+ * Upload `file` to binary-server in parts, resuming anything already delivered.
+ *
+ * Resolves once every part has landed and bs has assembled the object. The caller then tells
+ * its own app server to record the metadata — see each app's `/complete` route.
+ */
+export async function uploadDirect(
+	file: Blob,
+	session: UploadSession,
+	opts: DirectUploadOptions = {},
+): Promise<DirectUploadResult> {
+	const { onProgress, signal, refreshToken } = opts;
+	const concurrency = Math.max(1, opts.concurrency ?? 3);
+	const retries = Math.max(1, opts.retries ?? 5);
+	const { onLowDisk } = opts;
+	const total = session.totalChunks;
+
+	// A token can expire mid-upload on a slow line; `refreshToken` swaps in a new one and
+	// every subsequent request picks it up.
+	let token = session.token;
+
+	const prior = await fetchSessionState(session, token, signal);
+	if (prior.complete) {
+		return {
+			key: session.path,
+			size: prior.size ?? file.size,
+			checksum: prior.checksum,
+		};
+	}
+
+	// Bail before sending anything if the file plainly cannot land. bs keeps a reserve so a
+	// full disk never takes the Mac down, and it reports free space on the status call above —
+	// so an upload with nowhere to go costs one request instead of gigabytes of transfer.
+	const remainingBytes = file.size - prior.received.size * session.chunkBytes;
+	/*
+	 * 🔴 NO PREFLIGHT REFUSAL. Owner instruction, 2026-08-13: *"Remove all blockers for space
+	 * and only allow warning me. I'll manage space myself beyond that."*
+	 *
+	 * This used to throw when the remaining bytes exceeded the reported free space. It is gone
+	 * rather than softened because a client-side estimate is the WORST place to make this
+	 * call: `remainingBytes` counts every part not yet delivered, `freeBytes` was read before
+	 * the transfer began, and neither accounts for what the run itself frees or the owner
+	 * clears while it goes. binary-server no longer refuses either; the real limit is ENOSPC
+	 * from the filesystem, which is about the actual write rather than a projection.
+	 *
+	 * `onLowDisk` is the replacement, and it only WARNS.
+	 */
+	if (prior.freeBytes !== null && remainingBytes > prior.freeBytes) {
+		onLowDisk?.({ freeBytes: prior.freeBytes, needBytes: remainingBytes });
+	}
+
+	const pending = Array.from({ length: total }, (_, i) => i).filter((i) => !prior.received.has(i));
+	let done = total - pending.length;
+	let assembled: DirectUploadResult | null = null;
+
+	const report = (): void =>
+		onProgress?.(total === 0 ? 1 : done / total, done * session.chunkBytes, file.size);
+	report();
+
+	const sendOne = async (ci: number): Promise<void> => {
+		const start = ci * session.chunkBytes;
+		// Lazy view onto the file — nothing is read until fetch streams it.
+		const part = file.slice(start, Math.min(start + session.chunkBytes, file.size));
+
+		let lastErr: unknown;
+		for (let attempt = 0; attempt < retries; attempt++) {
+			signal?.throwIfAborted();
+			try {
+				const res = await fetch(chunkUrl(session, token, ci), {
+					method: "PUT",
+					body: part,
+					// bs stores the mime from the assembling request's content-type.
+					// 🔴 `x-allow-low-disk` is what turns binary-server's disk RESERVE from a
+					// wall into a warning. Owner instruction 2026-08-13, after a large upload
+					// stopped dead: *"Do not let the server block me. It can warn me and I can
+					// say do it anyway or cancel if I want."* The reserve is sized for the worst
+					// case a chunked upload can transiently need, so it refused uploads that
+					// would have fit. bs still refuses absolutely below its hard floor, where
+					// the machine itself is what is at risk.
+					headers: file.type ? { "content-type": file.type } : undefined,
+					signal,
+				});
+
+				if (res.status === 403 && refreshToken) {
+					// Almost always an expired session token on a long upload. Re-mint once per
+					// attempt and let the loop retry with it.
+					token = await refreshToken();
+					throw new Error("token refreshed, retrying");
+				}
+				// Out of space is terminal — retrying cannot make room, and a 10 GB upload
+				// hammering a full disk five times over is the opposite of helpful.
+				if (res.status === 507) {
+					const body = (await res.json().catch(() => ({}))) as {
+						freeBytes?: number;
+						overridable?: boolean;
+					};
+					// Terminal — retrying cannot make room, and a 10 GB upload hammering a full
+					// disk five times over is the opposite of helpful. 🔴 A CURRENT
+					// binary-server never sends this for its own reserve any more (see
+					// `overridable`); reaching here means the volume is genuinely out of room
+					// and the filesystem said so.
+					throw new InsufficientStorageError(
+						file.size,
+						body.freeBytes ?? null,
+						body.overridable === true,
+					);
+				}
+				if (!res.ok) throw new Error(`chunk ${ci}: HTTP ${res.status}`);
+
+				const body = (await res.json()) as {
+					assembled?: boolean;
+					size?: number;
+					checksum?: string | null;
+					key?: string;
+				};
+				if (body.assembled) {
+					assembled = {
+						key: body.key ?? session.path,
+						size: body.size ?? file.size,
+						checksum: body.checksum ?? null,
+					};
+				}
+				done++;
+				report();
+				return;
+			} catch (err) {
+				if (signal?.aborted) throw err;
+				// Terminal: no amount of backoff creates disk space.
+				if (err instanceof InsufficientStorageError) throw err;
+				lastErr = err;
+				// Backoff, capped — a home connection that dropped needs seconds, not minutes.
+				await sleep(Math.min(1000 * 2 ** attempt, 15_000));
+			}
+		}
+		throw new Error(
+			`chunk ${ci} failed after ${retries} attempts: ${
+				lastErr instanceof Error ? lastErr.message : String(lastErr)
+			}`,
+		);
+	};
+
+	// Bounded worker pool over the pending indices.
+	const queue = [...pending];
+	const workers = Array.from({ length: Math.min(concurrency, queue.length) }, async () => {
+		for (;;) {
+			const next = queue.shift();
+			if (next === undefined) return;
+			await sendOne(next);
+		}
+	});
+	await Promise.all(workers);
+
+	if (assembled) return assembled;
+
+	// Every part reported OK but no response carried the assemble result — possible if the
+	// final 201 was the one that got retried after its response was lost. Ask.
+	const after = await fetchSessionState(session, token, signal);
+	if (after.complete) {
+		return { key: session.path, size: after.size ?? file.size, checksum: after.checksum };
+	}
+	throw new Error(
+		`upload finished but binary-server did not assemble ${session.path} (${after.received.size}/${total} parts)`,
+	);
+}

package/src/react/media/FocusViewer.tsx

@@ -141,6 +141,7 @@ export interface FocusViewerProps {
 	onSaveSnapshot?: (
 		blob: Blob,
 		meta: { atSeconds: number },
+	// biome-ignore lint/suspicious/noConfusingVoidType: a handler that returns nothing is the common case, and `undefined` would reject every `() => {}` an app already passes
 	) => Promise<FocusSaveResult | void> | FocusSaveResult | void;
 	/** An arbitrary control in the action row — collections puts its folder picker here. */
 	destination?: React.ReactNode;

package/src/react/media/MediaThumb.tsx

@@ -136,7 +136,6 @@ export function MediaThumb({
   }
 
   return (
-    // biome-ignore lint/performance/noImgElement: cursedbelt has no framework image loader.
     <img
       data-cb-media-thumb='image'
       src={src}

package/src/react/media/VideoTurner.tsx

@@ -168,7 +168,6 @@ export function VideoTurner({
             full-width. Same correction, and the same measurement, as the gallery stage makes. */}
         <div className='cbpe-frame cbpe-frame-film' data-turned={swapsAxes(edit.turns) ? 'true' : undefined}>
           {cannotShow === null ? (
-            /* biome-ignore lint/a11y/useMediaCaption: arbitrary user-stored footage carries none */
             <video
               // A new source is a new attempt — see `failedSrc`.
               key={src}

package/src/react/media-gallery/GalleryTable.tsx

@@ -418,7 +418,6 @@ function TableVideoPreview({
     return () => releaseVideo(el);
   }, []);
   return (
-    // biome-ignore lint/a11y/useMediaCaption: a muted 56px preview of an arbitrary user file
     <video
       ref={ref}
       src={src}

package/src/react/media-gallery/MediaGallery.tsx

@@ -1383,7 +1383,6 @@ function GalleryStage({
             still takes a dwell timer: a run that reaches a track it cannot advance past stops
             dead. A mixed folder holding one voice memo used to end the album there. The two
             props stay mutually exclusive — a looping element never fires `ended`. */}
-        {/* biome-ignore lint/a11y/useMediaCaption: arbitrary user-stored files carry no captions */}
         <audio src={media.url} controls loop={repeat} {...(repeat ? {} : { onEnded })} />
       </div>
     );

package/src/styles-areas/activity-bar.css

@@ -1,5 +1,5 @@
 /*
- * cursedbelt — the `activity-bar` area. GENERATED BUILD ARTIFACT. Never hand-edit.
+ * cursedbelt — the `activity-bar` area's utility candidates. GENERATED BUILD ARTIFACT. Never hand-edit.
  *
  * the `cursedbelt/react/activity-bar` rail — app chrome most apps do not mount.
  *
@@ -13,18 +13,15 @@
  *   @import "cursedbelt/styles-areas/activity-bar.css";
  *   @import "cursedbelt/theme.css";
  *
- * An app that imports every area gets exactly what `cursedbelt/styles-utilities.css`
- * emits — proved rule by rule in src/stylesAreas.spec.ts, which is also what fails
- * when this file is stale. 71 candidate(s) scanned.
+ * These are CANDIDATES (`@source inline`), not CSS: the app's own Tailwind pass generates
+ * them, sorted together with the app's utilities, so an area can never put a base utility
+ * after an app's responsive variant (task 2124). An app that imports every area gets exactly
+ * what `cursedbelt/styles-utilities.css` emits — proved rule by rule in
+ * src/stylesAreas.spec.ts, which is also what fails when this file is stale.
+ * 1 candidate(s).
  *
  * Written by scripts/generateAreaStyles.ts (`bun run styles:areas`), which
  * `bun run build` runs. The map of what is in which area, and why the areas are
  * import closures rather than a hand-written list, is scripts/styleAreas.ts.
  */
-/*! tailwindcss v4.3.3 | MIT License | https://tailwindcss.com */
-@layer theme, base, components, utilities;
-@layer utilities {
-  .collapse {
-    visibility: collapse;
-  }
-}
+@source inline("collapse");