cursedbelt 4.3.0 → 4.4.0

package/src/demoFixture.spec.ts

@@ -4,6 +4,8 @@ import { resolve } from 'node:path';
 import {
 	DEMO_COMMAND,
 	DEMO_DEV_SCRIPT,
+	DEMO_DIST_DIR,
+	DEMO_HOST,
 	DEMO_PACKAGE_DIR,
 	DEMO_PORT,
 	DEMO_ROOT,
@@ -12,7 +14,8 @@ import {
 } from '../demo/devServer';
 import { DEMO_TSCONFIG, derivePaths, readDemoTsconfig, renderPathsBlock } from '../demo/generatePaths';
 import pkg from '../package.json';
-import { STAGES } from '../scripts/verify';
+// The declared graph, read as data — there is no scheduler in this repo to import from.
+const STAGES: readonly { script: string }[] = (pkg as { gate?: { stages?: { script: string }[] } }).gate?.stages ?? [];
 
 /**
  * 🔴 The e2e suite must never be able to sit green while it drives nothing.
@@ -56,19 +59,38 @@ describe('the e2e fixture exists', () => {
 		}
 		expect(pkg.scripts.demo, 'the demo script must start vite on the demo config').toInclude('demo/vite.config.ts');
 		// Playwright drives the BUILT bundle, not the dev server — see demo/devServer.ts.
-		expect(pkg.scripts['demo:serve'], 'demo:serve must build before it previews').toInclude('demo:build');
-		expect(pkg.scripts['demo:serve']).toInclude('vite preview');
+		expect(pkg.scripts['demo:serve'], 'demo:serve must build before it serves').toInclude('demo:build');
+		// 🔴 And it serves it from OUR server, never `vite preview` — which under Bun 1.4.2
+		// exits 1 with ERR_STREAM_WRITE_AFTER_END when a Playwright worker hangs up
+		// mid-response, reddening this gate about one run in four (task 388, 2026-09-18).
+		// Going back to it is a one-word edit, so it is a one-line assertion.
+		expect(pkg.scripts['demo:serve'], 'demo:serve must run scripts/demoServer.ts').toInclude('scripts/demoServer.ts');
+		expect(pkg.scripts['demo:serve'], '`vite preview` dies on a client hang-up under Bun').not.toInclude(
+			'vite preview',
+		);
 	});
 
-	it('both servers serve the port the specs are pointed at', () => {
+	it('every server serves the port the specs are pointed at', () => {
 		// vite silently walks to the next free port unless `strictPort` is set, which is
 		// the same outage wearing a costume: a server that starts perfectly well and a
-		// suite that times out against the port nobody is listening on.
+		// suite that times out against the port nobody is listening on. `Bun.serve` throws
+		// EADDRINUSE rather than walking, and `demoStaticServer.spec.ts` proves it does.
 		const viteConfig = readFileSync(resolve(DEMO_ROOT, 'vite.config.ts'), 'utf8');
-		expect(DEMO_URL).toBe(`http://localhost:${DEMO_PORT}`);
-		// Once for `server` (dev), once for `preview` (what e2e drives).
-		expect(viteConfig.match(/port: DEMO_PORT/g) ?? [], 'both server and preview must pin the port').toHaveLength(2);
-		expect(viteConfig.match(/strictPort: true/g) ?? [], 'both must set strictPort').toHaveLength(2);
+		expect(DEMO_URL).toBe(`http://${DEMO_HOST}:${DEMO_PORT}`);
+		// 🔴 A literal address, never `localhost`. Measured 2026-09-18: two demo servers
+		// bound 4318 at the same time — one on `[::1]`, one on `127.0.0.1` — because
+		// `localhost` resolves to both and each process took whichever its resolver offered
+		// first. Neither bind collided, and which one a client reached was its own
+		// resolution order. A name here is a gate that can silently test a stale bundle.
+		expect(DEMO_HOST, 'the fixture must not be reached through a name that resolves twice').toBe('127.0.0.1');
+		expect(viteConfig, 'the dev server must bind the same one address').toInclude('host: DEMO_HOST');
+		// Once, for `server` — the dev server a human runs. There is no `preview` block any
+		// more, and a second match here would mean one grew back unread.
+		expect(viteConfig.match(/port: DEMO_PORT/g) ?? [], 'the dev server must pin the port').toHaveLength(1);
+		expect(viteConfig.match(/strictPort: true/g) ?? [], 'and must set strictPort').toHaveLength(1);
+		expect(viteConfig, 'the preview block is dead config now — e2e is served by scripts/demoServer.ts').not.toInclude(
+			'preview:',
+		);
 	});
 
 	it('every page the specs navigate to is a real demo entry point', () => {
@@ -98,13 +120,35 @@ describe('the e2e fixture exists', () => {
 		expect(unlisted, `demo/vite.config.ts's rollup input omits:\n  ${unlisted.join('\n  ')}`).toEqual([]);
 	});
 
+	it('🔴 never reuses a server somebody else started', () => {
+		// The gate's meaning must not depend on what the previous agent in this checkout
+		// left running. `reuseExistingServer: !process.env.CI` meant exactly that: `CI` is
+		// unset on this Mac, so a stale listener on 4318 was silently adopted and the demo
+		// build was skipped. Two agents measured the same command at 34.8s and 45.0s on
+		// 2026-09-18 for that reason — the fast one tested a bundle nobody had rebuilt.
+		const config = readFileSync(resolve(e2eDir, 'playwright.config.ts'), 'utf8');
+		expect(config, 'the webServer must always be ours').toInclude('reuseExistingServer: false');
+		expect(config, 'reuse must not be conditional on an env var this machine never sets').not.toMatch(
+			/reuseExistingServer:\s*!?\s*process\.env/,
+		);
+	});
+
+	it('serves exactly the directory the demo build writes', () => {
+		// `scripts/demoServer.ts` serves DEMO_DIST_DIR; vite writes to `outDir` resolved
+		// against its `root`. A custom `outDir` would leave the server pointed at an empty
+		// directory and every spec 404ing against a 200-answering process.
+		const viteConfig = readFileSync(resolve(DEMO_ROOT, 'vite.config.ts'), 'utf8');
+		expect(DEMO_DIST_DIR).toBe(resolve(DEMO_ROOT, 'dist'));
+		expect(viteConfig, 'demoServer.ts assumes vite’s default outDir').not.toInclude('outDir');
+	});
+
 	it('verify actually runs the suite', () => {
 		// Everything above proves the fixture resolves. Only this proves anybody looks:
 		// without it, `e2e` drops back out of the gate and this whole file becomes a
 		// comment about a suite nothing runs.
 		//
 		// 🔴 `verify` stopped being an `&&` chain on 2026-09-15 and became a dependency
-		// graph (`scripts/verify.ts`), so "the script mentions e2e" is no longer where the
+		// graph (the `gate` block in `package.json`), so "the script mentions e2e" is no longer where the
 		// answer lives. Asking the graph is strictly stronger than asking the string was:
 		// `verifyGraph.spec.ts` additionally pins that every OTHER stage of the old chain
 		// is still in it, which the `toInclude` never checked for any of them.

package/src/demoStaticServer.spec.ts

@@ -0,0 +1,169 @@
+/**
+ * 🔴 The demo's static server, and specifically the fault that used to end the gate.
+ *
+ * `bun run verify` went red about one run in four on an unmodified tree (task 388,
+ * 2026-09-18): `vite preview` — connect on Bun's `node:http` shim — threw
+ * `ERR_STREAM_WRITE_AFTER_END` out of `advanceResponsePipeline` when a Playwright worker
+ * hung up on a response that was still being written, and the throw landed after the
+ * handler had returned, where no middleware could catch it. The process exited 1, the
+ * `webServer` never came ready, and 138 innocent specs went red 120 seconds later.
+ *
+ * So the first assertion here is the one that matters: abort requests mid-flight and prove
+ * the server is still serving afterwards. Everything else in this file is the ordinary
+ * contract that makes the fixture pages reachable at all.
+ */
+import { describe, expect, it } from 'bun:test';
+import { mkdirSync, mkdtempSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join, resolve } from 'node:path';
+import { DEMO_HOST, DEMO_URL } from '../demo/devServer';
+import { isPeerHangup, resolveRequestPath, startDemoServer } from '../scripts/demoServer';
+
+/**
+ * A throwaway `dist` shaped like the one `bun run demo:build` writes. `$TMPDIR` is already
+ * redirected into this repo's scratch root by `scripts/testTmpRoot.ts` in the preload.
+ */
+function fixtureRoot(): string {
+	const root = mkdtempSync(join(tmpdir(), 'demo-server-'));
+	mkdirSync(resolve(root, 'assets'), { recursive: true });
+	writeFileSync(resolve(root, 'index.html'), '<!doctype html><title>kitchen sink</title>');
+	writeFileSync(resolve(root, 'table-layout.html'), '<!doctype html><title>table layout</title>');
+	// Big enough that an abort lands mid-body rather than after the whole thing arrived.
+	writeFileSync(resolve(root, 'assets', 'app.js'), `export const pad = '${'x'.repeat(4_000_000)}';\n`);
+	writeFileSync(resolve(root, 'assets', 'app.css'), ':root { color-scheme: dark; }\n');
+	return root;
+}
+
+/** Runs `body` against a server on an ephemeral port, and always stops it. */
+async function withServer(body: (base: string) => Promise<void>): Promise<void> {
+	const server = startDemoServer({ root: fixtureRoot(), port: 0, hostname: '127.0.0.1' });
+	try {
+		await body(`http://127.0.0.1:${server.port}`);
+	} finally {
+		await server.stop(true);
+	}
+}
+
+describe('🔴 a client that hangs up is a non-event', () => {
+	it('keeps serving after a burst of aborted requests', async () => {
+		await withServer(async (base) => {
+			expect((await fetch(`${base}/`)).status, 'the server must be up before we abort at it').toBe(200);
+
+			// Eight, because that is how many Playwright workers this repo runs, and each one
+			// abandons in-flight subresources on every navigation.
+			for (let i = 0; i < 8; i++) {
+				const control = new AbortController();
+				const inFlight = fetch(`${base}/assets/app.js`, { signal: control.signal });
+				// Abort on the next turn of the loop: late enough that the response is being
+				// written, early enough that the body has not finished.
+				queueMicrotask(() => control.abort());
+				await inFlight.then(
+					async (response) => {
+						// If it won the race, drain it and abort during the read instead.
+						control.abort();
+						await response.text().catch(() => undefined);
+					},
+					() => undefined,
+				);
+			}
+
+			// The whole point. Under `vite preview` the process was gone by now.
+			const after = await fetch(`${base}/`);
+			expect(after.status, 'the server died on a client hang-up — the exact task-388 bug').toBe(200);
+			expect(await after.text()).toInclude('kitchen sink');
+		});
+	});
+
+	it('names the peer faults it tolerates, and nothing else', () => {
+		// 🔴 A blanket handler would keep a broken server alive and let the gate measure a
+		// corpse that answers 200. The list is closed; this is the negative control.
+		expect(isPeerHangup({ code: 'ERR_STREAM_WRITE_AFTER_END' })).toBe(true);
+		expect(isPeerHangup({ code: 'ECONNRESET' })).toBe(true);
+		expect(isPeerHangup({ code: 'EPIPE' })).toBe(true);
+		expect(isPeerHangup(Object.assign(new Error('aborted'), { name: 'AbortError' }))).toBe(true);
+		expect(isPeerHangup(new TypeError('x is not a function'))).toBe(false);
+		expect(isPeerHangup({ code: 'ENOSPC' })).toBe(false);
+		expect(isPeerHangup(null)).toBe(false);
+		expect(isPeerHangup('ECONNRESET')).toBe(false);
+	});
+});
+
+describe('the pages the specs navigate to', () => {
+	it('serves the fixture pages, with the right content type and no caching', async () => {
+		await withServer(async (base) => {
+			const index = await fetch(`${base}/`);
+			expect(index.status).toBe(200);
+			expect(index.headers.get('content-type')).toInclude('text/html');
+			// 🔴 A cached bundle is a gate reading pre-checkout code, which is the trap this
+			// whole change exists to close.
+			expect(index.headers.get('cache-control')).toInclude('no-store');
+
+			const page = await fetch(`${base}/table-layout.html`);
+			expect(page.status).toBe(200);
+			expect(await page.text()).toInclude('table layout');
+
+			const css = await fetch(`${base}/assets/app.css`);
+			expect(css.status).toBe(200);
+			expect(css.headers.get('content-type')).toInclude('text/css');
+		});
+	});
+
+	it('404s what it does not have, rather than answering with index.html', async () => {
+		// A SPA fallback here would make `demoFixture.spec.ts`'s "every page the specs
+		// navigate to is real" assertion unfalsifiable at runtime: a typo'd fixture URL
+		// would load the kitchen sink and fail on a missing selector instead.
+		await withServer(async (base) => {
+			expect((await fetch(`${base}/no-such-page.html`)).status).toBe(404);
+			expect((await fetch(`${base}/assets/`)).status, 'no directory listings').toBe(404);
+		});
+	});
+});
+
+describe('what it refuses to serve', () => {
+	const root = '/tmp/demo-dist';
+
+	it('resolves the shapes the fixture actually uses', () => {
+		expect(resolveRequestPath(root, '/../../etc/passwd')).toBeNull();
+		expect(resolveRequestPath(root, '/%2e%2e/%2e%2e/etc/passwd')).toBeNull();
+		expect(resolveRequestPath(root, '/%zz')).toBeNull();
+		expect(resolveRequestPath(root, '/nope.html')).toBeNull();
+	});
+
+	it('cannot be walked out of its root even through an encoded traversal', async () => {
+		// The pure check above says `null`; this says the socket agrees, because a server
+		// that resolved correctly and then read the file anyway would pass the first.
+		await withServer(async (base) => {
+			for (const path of ['/../package.json', '/%2e%2e/package.json', '/..%2fpackage.json']) {
+				const response = await fetch(`${base}${path}`);
+				expect(await response.text(), `${path} escaped the demo dist`).not.toInclude('cursedbelt');
+			}
+		});
+	});
+});
+
+describe('the port', () => {
+	it('🔴 binds one literal address, so a second server cannot hide beside it', async () => {
+		// Measured 2026-09-18: with `hostname: 'localhost'` two processes bound 4318 at once,
+		// one on `[::1]` and one on `127.0.0.1`, and NEITHER raised EADDRINUSE — `localhost`
+		// resolves to both, so they were never competing for the same socket. The gate would
+		// then test whichever one the client happened to reach.
+		const server = startDemoServer({ root: fixtureRoot(), port: 0 });
+		try {
+			expect(server.hostname, 'a resolvable NAME here is two sockets pretending to be one').toBe(DEMO_HOST);
+			expect(DEMO_URL).toInclude(DEMO_HOST);
+		} finally {
+			await server.stop(true);
+		}
+	});
+
+	it('🔴 refuses a taken port instead of walking to the next one', async () => {
+		// The same rule `strictPort: true` gave the vite servers: a fixture that quietly
+		// moves to 4319 is a suite that times out against the port it was pointed at.
+		const first = startDemoServer({ root: fixtureRoot(), port: 0, hostname: '127.0.0.1' });
+		try {
+			expect(() => startDemoServer({ root: fixtureRoot(), port: first.port, hostname: '127.0.0.1' })).toThrow();
+		} finally {
+			await first.stop(true);
+		}
+	});
+});

package/src/publishShape.spec.ts

@@ -52,6 +52,31 @@ const typesThatAreNotDeclarations = (exports: Record<string, unknown>): string[]
 		.filter(([, target]) => !target.endsWith('.d.ts'))
 		.map(([subpath, target]) => `${subpath} → ${target}`);
 
+/**
+ * Every `[subpath, condition, target]` this manifest resolves OUTSIDE `dist/`.
+ *
+ * `./dist/` is deliberately excluded: those are `scripts/checkDistExports.ts`' job, and it
+ * has to be a build step because `dist/` is the one directory no spec here may open
+ * (`src/verifyGraph.spec.ts` asserts it, because `build` runs beside `test`). Everything
+ * else is a file that is already on disk when the tests run, so it belongs here.
+ *
+ * A string-valued export (`'./styles.css': './src/styles.css'`) is one target under the
+ * implicit `default` condition — 48 of this manifest's entries are that shape.
+ */
+const targetsOutsideDist = (exports: Record<string, unknown>): [string, string, string][] => {
+	const out: [string, string, string][] = [];
+	for (const [subpath, entry] of Object.entries(exports)) {
+		const conditions: Record<string, unknown> =
+			typeof entry === 'string' ? { default: entry } : typeof entry === 'object' && entry !== null ? (entry as Record<string, unknown>) : {};
+		for (const [condition, target] of Object.entries(conditions)) {
+			if (typeof target === 'string' && target.startsWith('./') && !target.startsWith('./dist/')) {
+				out.push([subpath, condition, target]);
+			}
+		}
+	}
+	return out;
+};
+
 describe('publish shape', () => {
 	it('ships every directory its exports resolve into', () => {
 		const files = (pkg as { files?: string[] }).files ?? [];
@@ -147,7 +172,61 @@ describe('publish shape', () => {
 		expect(typesThatAreNotDeclarations({ './a': { types: './dist/a.js' } })).toHaveLength(1);
 	});
 
+	it('🔴 points every non-dist export condition at a file that EXISTS', async () => {
+		// ── The third of three ways this manifest can lie, and the only one nothing watched ──
+		// `publishShape` above proves an export's ROOT directory is in `files`;
+		// `scripts/checkDistExports.ts` proves every `./dist/` target was emitted. Between
+		// them sits the condition a consumer actually RUNS — `bun`/`source`/`default`, which
+		// for this package is raw `./src/**` and `./scripts/guardrailsEnforce.ts` — and
+		// nothing proved those files are there. `files` ships whole directories, so renaming
+		// or moving one leaves the root shipped, the tarball valid, and the target dangling.
+		//
+		// It is not hypothetical and it is not ours to survive: since task 202 folded
+		// `--baseline` into the scanner, SIX apps run
+		// `bun node_modules/cursedbelt/scripts/guardrailsEnforce.ts …` inside their own
+		// `verify`. That path and this manifest's `./guardrails` conditions name the same
+		// file, so the day it moves, six repos go red in a file none of them wrote — the
+		// exact three-repos-away failure that tasks 172 and 219 each cost a session to find.
+		//
+		// The 48 string-valued CSS entries are the sharper half: they are GENERATED
+		// (`bun run styles:areas`) and have no second condition to fall through to, so a
+		// generator that stops emitting one is an unresolvable import for every consumer
+		// with nothing red on this side at all.
+		const repo = `${import.meta.dir}/..`;
+		const missing: string[] = [];
+		for (const [subpath, condition, target] of targetsOutsideDist(pkg.exports as unknown as Record<string, unknown>)) {
+			// 🔴 Bun.file, NOT node:fs — the preload virtualizes node:fs and an existsSync
+			// here would answer from MOCK data. Same trap as the header of this file.
+			if (!(await Bun.file(`${repo}/${target.slice(2)}`).exists())) missing.push(`${subpath} [${condition}] → ${target}`);
+		}
+		expect(
+			missing,
+			'these export conditions name a file that is not on disk. A consumer does not get a\n' +
+				'helpful error — the resolver falls through to whatever condition is left, or fails\n' +
+				'outright for the CSS entries, which have none:\n  ' +
+				missing.join('\n  '),
+		).toEqual([]);
+	});
+
+	it('catches a dangling non-dist target, and leaves dist to the build step', () => {
+		// The negative control for the rule above. Without it, `targetsOutsideDist` could
+		// quietly stop matching and the assertion would be green against nothing.
+		const found = targetsOutsideDist({
+			'./guardrails': { types: './dist/scripts/guardrailsEnforce.d.ts', bun: './scripts/moved.ts' },
+			'./styles.css': './src/styles.css',
+			'./react': { types: './dist/react/index.d.ts', import: './dist/react/index.js' },
+		});
+		// The `./dist/` conditions are checkDistExports' to police, so neither appears here.
+		expect(found).toEqual([
+			['./guardrails', 'bun', './scripts/moved.ts'],
+			['./styles.css', 'default', './src/styles.css'],
+		]);
+	});
+
 	it('reads the real manifest, so the rule cannot pass vacuously', () => {
+		// The scan above must see the whole non-dist surface, not a handful of it: 97 targets
+		// across the `bun`/`source`/`default` conditions and the 48 bare CSS entries.
+		expect(targetsOutsideDist(pkg.exports as unknown as Record<string, unknown>).length).toBeGreaterThan(90);
 		// `types` is what every conditional export in this package leads with; if the scan
 		// ever returns nothing, both assertions above are green about a manifest they never
 		// looked at.

package/src/react/components/Autocomplete.tsx

@@ -138,7 +138,17 @@ export function AutocompleteField<S = string>({
       </Autocomplete.InputGroup>
 
       <Autocomplete.Portal>
-        <Autocomplete.Positioner sideOffset={4} collisionPadding={FLOATING_COLLISION_PADDING}>
+        {/* 🔴 The z-index goes on the POSITIONER, not only the popup. Base UI's positioner is
+            the element that is `position: absolute` (with a transform); the popup inside it is
+            `position: static`, so the popup's own `z-[var(--z-popover)]` does nothing and the
+            list painted UNDER any sibling with a z-index — measured 2026-09-22 in the
+            binary-server inspector, a sticky table header (z-index 1) covering the second option
+            of an open MultiSelectField. */}
+        <Autocomplete.Positioner
+          sideOffset={4}
+          collisionPadding={FLOATING_COLLISION_PADDING}
+          className='z-[var(--z-popover)]'
+        >
           <Autocomplete.Popup
             className={cn(
               FLOATING_CONTENT_BASE,

package/src/react/components/ComboboxField.spec.tsx

@@ -53,6 +53,18 @@ describe('ComboboxField (single)', () => {
     expect(getByText('Banana')).not.toBeNull();
   });
 
+  test('🔴 the POSITIONER carries the popover z-index — the popup is static inside it', () => {
+    const { container, getByRole } = render(<Controlled />);
+    const trigger = container.querySelector('[aria-label="Toggle options"]') as HTMLElement;
+    act(() => {
+      fireEvent.click(trigger);
+    });
+    const popup = getByRole('listbox').closest('[data-side]') as HTMLElement;
+    const positioner = popup.parentElement?.closest('[data-side]') as HTMLElement;
+    expect(positioner).not.toBeNull();
+    expect(positioner.className).toContain('z-[var(--z-popover)]');
+  });
+
   test('disabled prevents the trigger from responding', () => {
     const onChange = mock(() => {});
     const { container } = render(

package/src/react/components/ComboboxField.tsx

@@ -291,7 +291,17 @@ export function ComboboxField(props: ComboboxFieldProps) {
       </Combobox.InputGroup>
 
       <Combobox.Portal>
-        <Combobox.Positioner sideOffset={4} collisionPadding={FLOATING_COLLISION_PADDING}>
+        {/* 🔴 The z-index goes on the POSITIONER, not only the popup. Base UI's positioner is
+            the element that is `position: absolute` (with a transform); the popup inside it is
+            `position: static`, so the popup's own `z-[var(--z-popover)]` does nothing and the
+            list painted UNDER any sibling with a z-index — measured 2026-09-22 in the
+            binary-server inspector, a sticky table header (z-index 1) covering the second option
+            of an open MultiSelectField. */}
+        <Combobox.Positioner
+          sideOffset={4}
+          collisionPadding={FLOATING_COLLISION_PADDING}
+          className='z-[var(--z-popover)]'
+        >
           <Combobox.Popup
             className={cn(
               FLOATING_CONTENT_BASE,

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

@@ -1027,6 +1027,14 @@ describe('MediaGallery — size and length', () => {
     expect(tileLine(container, 'notes.pdf')).toBe('5.0 MB');
   });
 
+  test("'length-and-size' puts both facts on a film's tile, and a document keeps its size", () => {
+    const { container } = render(
+      <MediaGallery items={MEASURED} meta={{ tileMeasure: 'length-and-size' }} />,
+    );
+    expect(tileLine(container, 'holiday.mp4')).toBe('3:07 · 1.3 GB');
+    expect(tileLine(container, 'notes.pdf')).toBe('5.0 MB');
+  });
+
   test('tags keep their line and the running time joins them on it', () => {
     // 🔴 Never a fourth line: the caption block is a fixed 65px (`CBGD_META_HEIGHT`), and a
     // tile taller than its neighbour is what made rows lap each other across the fleet.
@@ -1116,6 +1124,21 @@ describe('MediaGallery — size and length', () => {
         { measure: true },
       ),
     ).toBe('1:05');
+    // `length-and-size` keeps the size beside the running time — binary-server's ask, both
+    // facts on one tile — and a clip nobody measured is just its size, never `— · 1.3 GB`.
+    expect(galleryTileLine(film, { measure: 'length-and-size' })).toBe('3:07 · 1.3 GB');
+    expect(
+      galleryTileLine({ ...film, tags: ['collections'] }, { measure: 'length-and-size' }),
+    ).toBe('collections · 3:07 · 1.3 GB');
+    expect(
+      galleryTileLine({ ...film, durationSeconds: undefined }, { measure: 'length-and-size' }),
+    ).toBe('1.3 GB');
+    expect(
+      galleryTileLine({ id: 'v', name: 'bare.mp4', category: 'video' }, { measure: 'length-and-size' }),
+    ).toBe('—');
+    expect(
+      galleryTileLine({ id: 'd', name: 'doc.pdf', sizeBytes: 900 }, { measure: 'length-and-size' }),
+    ).toBe('900 B');
     // Off, nothing about the line moves — tags win, then the size, then nothing at all.
     expect(galleryTileLine({ ...film, tags: ['holiday'] })).toBe('holiday');
     expect(galleryTileLine({ id: 'x', name: 'bare.bin' })).toBeNull();

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

@@ -445,6 +445,10 @@ function isTurned(item: MediaGalleryItem): boolean {
   return item.orientation ? swapsAxes(item.orientation.turns) : false;
 }
 
+/** What a tile's caption measures — see {@link galleryTileLine}. `true` = the running time on a
+ *  time-based item (else its size); `'length-and-size'` = both, side by side. */
+export type TileMeasure = boolean | 'length-and-size';
+
 type BytesCache = MutableRefObject<Map<string, Promise<ArrayBuffer>>>;
 
 /**
@@ -473,19 +477,28 @@ type BytesCache = MutableRefObject<Map<string, Promise<ArrayBuffer>>>;
  */
 export function galleryTileLine(
   item: MediaGalleryItem,
-  options: { measure?: boolean } = {},
+  options: { measure?: TileMeasure } = {},
 ): string | null {
   const tags = item.tags && item.tags.length > 0 ? item.tags.slice(0, 3).join(' · ') : null;
   const size = item.sizeBytes != null ? formatBytes(item.sizeBytes) : null;
   if (!options.measure) return tags ?? size;
   const category = galleryItemCategory(item);
   const timeBased = category === 'video' || category === 'audio';
-  const measure = timeBased ? (durationLabel(item.durationSeconds) ?? size ?? '—') : size;
+  const length = timeBased ? durationLabel(item.durationSeconds) : null;
+  // `length-and-size` keeps the size BESIDE the running time instead of dropping it — the
+  // binary-server inspector's ask, which named both facts for the same tile. A clip with no
+  // measured length is then just its size, never `— · 1.3 GB`.
+  const measure =
+    options.measure === 'length-and-size'
+      ? ([length, size].filter(Boolean).join(' · ') || (timeBased ? '—' : null))
+      : timeBased
+        ? (length ?? size ?? '—')
+        : size;
   return tags && measure ? `${tags} · ${measure}` : (tags ?? measure);
 }
 
-function GalleryMeta({ item, measure }: { item: MediaGalleryItem; measure?: boolean }) {
-  const line = galleryTileLine(item, { measure: measure === true });
+function GalleryMeta({ item, measure }: { item: MediaGalleryItem; measure?: TileMeasure }) {
+  const line = galleryTileLine(item, { measure });
   // The date is its OWN line rather than appended to the one above, because that line is
   // already whichever of tags/size exists — folding a third fact into it would push the tags
   // out of a tile caption that is two lines tall by design.
@@ -647,7 +660,7 @@ function GalleryTile({
   /** Preview every video tile without hovering it — see `readThumbAutoplay`. */
   autoPreview?: boolean;
   /** Lead the caption with a running time / a size — see {@link galleryTileLine}. */
-  measure?: boolean;
+  measure?: TileMeasure;
   /** See {@link TileShell}'s `stageMark` — the label for the tile that is ON the stage. */
   stageMark?: string;
 }) {
@@ -741,7 +754,7 @@ function RawGalleryTile({
   cache: MediaCache;
   onOpen: () => void;
   autoPreview?: boolean;
-  measure?: boolean;
+  measure?: TileMeasure;
 }) {
   const category = galleryItemCategory(item);
   const { media } = useItemMedia(item, cache);
@@ -1749,8 +1762,12 @@ export interface MediaGalleryProps {
      * A tile's caption leads with the measurement that means something for its kind: the
      * RUNNING TIME on a film or a track, the size on everything else. Tags keep the line
      * they had and the measurement joins them on it — see {@link galleryTileLine}.
+     *
+     * `'length-and-size'` shows BOTH on a film or a track (`3:07 · 1.3 GB`) rather than the
+     * running time instead of the size — `ideas/binary-server-09-15.md` asked for the two
+     * facts on the same tile, where `collections` asked for one in place of the other.
      */
-    tileMeasure?: boolean;
+    tileMeasure?: TileMeasure;
     /**
      * The table offers the exact byte count as its own column, beside the rounded Size one
      * rather than instead of it — see `exactBytesLabel` in `GalleryTable.tsx`. A rounded size cannot answer
@@ -3094,7 +3111,7 @@ export function MediaGallery({
               // …and so does the running time on a film's caption: the strip under an open
               // file is the same grid, and a tile that told you its length on one screen and
               // its size on the other would be two tiles.
-              measure={meta?.tileMeasure === true}
+              measure={meta?.tileMeasure || undefined}
               // The one tile the stage is showing. Clicking it re-selects what is already
               // open, which `select` makes a no-op change — it stays a live tile rather than
               // a dead one, because a tile you cannot press reads as broken.
@@ -3292,7 +3309,7 @@ export function MediaGallery({
             selection={tileSelection(item)}
             drag={tileDrag(item)}
             autoPreview={thumbAutoplay}
-            measure={meta?.tileMeasure === true}
+            measure={meta?.tileMeasure || undefined}
           />
         ) : null;
       }}

package/src/styles-areas/analytics.css

@@ -15,7 +15,7 @@
  *
  * 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. 1309 candidate(s) scanned.
+ * when this file is stale. 1312 candidate(s) scanned.
  *
  * 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

package/src/styles-areas/data-table.css

@@ -15,7 +15,7 @@
  *
  * 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. 1345 candidate(s) scanned.
+ * when this file is stale. 1347 candidate(s) scanned.
  *
  * 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

package/src/styles-areas/fields.css

@@ -15,7 +15,7 @@
  *
  * 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. 610 candidate(s) scanned.
+ * when this file is stale. 613 candidate(s) scanned.
  *
  * 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

package/src/styles-areas/media-gallery.css

@@ -15,7 +15,7 @@
  *
  * 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. 2113 candidate(s) scanned.
+ * when this file is stale. 2115 candidate(s) scanned.
  *
  * 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

package/src/styles-areas/wizard.css

@@ -15,7 +15,7 @@
  *
  * 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. 386 candidate(s) scanned.
+ * when this file is stale. 389 candidate(s) scanned.
  *
  * 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

package/src/testFilesRunInParallel.spec.ts

@@ -13,7 +13,7 @@
  * | **`--parallel=6`** | **14.6s** | 2689 / 0 |
  * | `--parallel` (14) | 11.8s | 2689 / 0 |
  *
- * Six, not fourteen, and the reason is the one `scripts/verify.ts` gives for its own job
+ * Six, not fourteen, and the reason is the one `$FORGE/tools/gate.ts` gives for its own job
  * cap: `test` runs BESIDE `e2e` in the graph, and e2e is seven Playwright workers driving
  * seven browsers. Fourteen more processes on top converts parallelism into thrash, and
  * browser specs degrade worse than anything else under contention. The gain from 6 → 14 is
@@ -57,7 +57,7 @@ describe('the unit suite runs on more than one core', () => {
   });
 
   test('the worker count stays inside the budget the verify graph assumes', () => {
-    // `scripts/verify.ts` runs up to `jobLimit()` stages at once and `e2e` is seven
+    // `$FORGE/tools/gate.ts` runs up to `jobLimit()` stages at once and `e2e` is seven
     // browsers. A bare `--parallel` means one worker per core, which is that budget
     // ignored — so the number is written down, and it is written down here as well as in
     // package.json because the two have to agree about why.
@@ -71,7 +71,7 @@ describe('the unit suite runs on more than one core', () => {
     expect(workers).toBeGreaterThanOrEqual(2);
     expect(
       workers,
-      'more workers than a third of the cores is the over-subscription `scripts/verify.ts` ' +
+      'more workers than a third of the cores is the over-subscription `$FORGE/tools/gate.ts` ' +
         'caps its own stage count to avoid; measured, 6 → 14 workers buys 2.8s and is paid ' +
         'for by the browser stage running beside it.',
     ).toBeLessThanOrEqual(8);