cursedbelt 3.0.2 → 4.0.0

package/src/react/media-gallery/mediaMeta.ts

@@ -0,0 +1,101 @@
+import type { MediaGalleryItem } from './types';
+
+/**
+ * Tags and a description, expressed as a CHANGE rather than as a new value.
+ *
+ * ── Why a change and not a pair of fields ──────────────────────────────────────────────
+ * The owner's ask, `ideas/collections-09-14.md`, 2026-09-14: *"In media galleries have an
+ * option for apps to tag media and aadd descriptions to media."* The case he will actually
+ * hit is forty holiday photographs at once, and forty items do not share one tag list — each
+ * one has its own, and "the new tags" cannot be a single array without wiping thirty-nine
+ * lists that were never on screen.
+ *
+ * So the plural verb carries `addTags`/`removeTags`, which mean the same thing for one item
+ * as for forty, and a consumer writes ONE handler rather than a singular one plus a loop.
+ * That is the rule `tasks/Completed/240-*.md` states for the file tree's multi-select in as
+ * many words — *"One request for N ids, not N requests: the tree deliberately does not loop
+ * `onMove`, because a tree re-derived between each write is how a batch move half-lands."*
+ *
+ * 🔴 Everything here is case-INSENSITIVE and spelling-preserving. A vocabulary that mints
+ * `Bank`, `bank` and `BANK` as three tags is a vocabulary nothing can filter by, and the
+ * gallery's own chips would show all three. The first spelling seen wins; a tag that differs
+ * only in case from one already present is not an addition at all.
+ */
+export interface MediaMetaChange {
+  /** Tags to add to EVERY item in the set. Already trimmed, de-duplicated, never empty strings. */
+  addTags: string[];
+  /** Tags to remove from EVERY item in the set. Matched case-insensitively. */
+  removeTags: string[];
+  /**
+   * The new description, or `''` to clear it. `undefined` means "not part of this change" —
+   * which is what a bulk tag always sends, because one sentence cannot describe forty files
+   * and writing it onto all of them would delete thirty-nine that were never read.
+   */
+  description?: string;
+}
+
+/** Trim, drop the empties, drop case-insensitive duplicates keeping the first spelling. */
+export function cleanTags(tags: readonly string[]): string[] {
+  const seen = new Set<string>();
+  const out: string[] = [];
+  for (const raw of tags) {
+    const tag = raw.trim();
+    if (!tag) continue;
+    const key = tag.toLowerCase();
+    if (seen.has(key)) continue;
+    seen.add(key);
+    out.push(tag);
+  }
+  return out;
+}
+
+/**
+ * What it takes to get from `before` to `after` — the single-item editor's save, expressed in
+ * the same two lists the bulk one sends, so both paths arrive at a consumer as one shape.
+ */
+export function tagDiff(
+  before: readonly string[] | undefined,
+  after: readonly string[],
+): { addTags: string[]; removeTags: string[] } {
+  const was = cleanTags(before ?? []);
+  const now = cleanTags(after);
+  const wasKeys = new Set(was.map((t) => t.toLowerCase()));
+  const nowKeys = new Set(now.map((t) => t.toLowerCase()));
+  return {
+    addTags: now.filter((tag) => !wasKeys.has(tag.toLowerCase())),
+    removeTags: was.filter((tag) => !nowKeys.has(tag.toLowerCase())),
+  };
+}
+
+/** Nothing to save. The editor's Save is disabled on this, so a no-op never reaches an app. */
+export function isEmptyMetaChange(change: MediaMetaChange): boolean {
+  return (
+    change.addTags.length === 0 &&
+    change.removeTags.length === 0 &&
+    change.description === undefined
+  );
+}
+
+/**
+ * The merge a consumer would otherwise write itself — one item's row after the change lands.
+ *
+ * Exported for the same reason `fileTreeSelection.ts`'s rules are: the gallery persists
+ * nothing, so every app has to do this arithmetic, and four apps re-deriving "add these,
+ * remove those, keep the spelling" is four chances to mint a duplicate tag. `tags` comes back
+ * cleaned; `description` is omitted from the result when the change did not carry one, so a
+ * caller can spread the result over its row without clearing a description it never touched.
+ */
+export function applyMetaChange(
+  item: Pick<MediaGalleryItem, 'tags' | 'description'>,
+  change: MediaMetaChange,
+): { tags: string[]; description?: string } {
+  const removed = new Set(change.removeTags.map((t) => t.toLowerCase()));
+  const kept = cleanTags(item.tags ?? []).filter((tag) => !removed.has(tag.toLowerCase()));
+  const tags = cleanTags([...kept, ...change.addTags]);
+  return change.description === undefined ? { tags } : { tags, description: change.description };
+}
+
+/** Every tag on any of these items, cleaned and in first-seen order — the "Remove" vocabulary. */
+export function tagsOn(items: readonly Pick<MediaGalleryItem, 'tags'>[]): string[] {
+  return cleanTags(items.flatMap((item) => item.tags ?? []));
+}

package/src/react/media-gallery/playbackPreferences.spec.ts

@@ -0,0 +1,172 @@
+import { describe, expect, spyOn, test } from 'bun:test';
+import {
+  DEFAULT_SESSION_VOLUME,
+  PLAYER_VOLUME_KEY,
+  readSessionVolume,
+  STAGE_VOLUME_KEY,
+  writePlaybackEnd,
+  writeSessionVolume,
+} from './playbackPreferences';
+
+/**
+ * 🔴 The volume he set stays set for the PAGE — and is gone on the next one.
+ *
+ * Owner, `ideas/collections-09-14.md`: *"Keep the media player volume where I set it after
+ * changing it during a session except if I refresh or first log in then continue starting it
+ * at mute. Then if I unmute it, keep that value as I change to other videos."*
+ *
+ * Three rules, and every one of them is asserted below, because each fails silently:
+ *
+ *   · a fresh page starts MUTED — a stored level would have to be noticed to be undone
+ *   · a level set on one clip reaches the next — the whole ask
+ *   · a refresh forgets it — which is why the value is held in memory, and is proven here as
+ *     "neither web store is touched". 🔴 That is the load-bearing assertion in this file:
+ *     `sessionStorage` sounds like the right home and is not, because it is cleared when the
+ *     TAB closes rather than when the page loads (measured in this repo's own Chromium:
+ *     write, reload, the value is still there). Moving this onto either store brings his
+ *     volume back loud across exactly the gesture he asked to return to silence, and nothing
+ *     else in the suite would see it.
+ *
+ * The starting values the player derives from these live in `media/VideoPlayer.tsx`
+ * (`resolveAutoplay`) and are asserted in its own spec — a Vidstack player under happy-dom is
+ * an inert custom element, so the decision has to be readable without one.
+ *
+ * Every test below writes under a key of its own rather than under the two real ones, for the
+ * reason the map exists at all: a page-lifetime value has no teardown, so tests that shared a
+ * key would be an ordering dependency in a file about remembering things.
+ */
+
+describe('the session volume', () => {
+  test('🔴 a surface nobody has touched has nothing set — so it starts at mute', () => {
+    // `null`, NOT the default value: the player has to be able to tell "he has not touched
+    // it" from "he set it to 1.0 unmuted", or every click-to-play consumer in the fleet gets
+    // silently muted on upgrade. See `readSessionVolume`.
+    expect(readSessionVolume('test:untouched')).toBeNull();
+    // And the fallback the player uses in that case is silent.
+    expect(DEFAULT_SESSION_VOLUME.muted).toBe(true);
+  });
+
+  test('a level set on one item is what the next item reads', () => {
+    writeSessionVolume('test:carries-over', { volume: 0.4, muted: false });
+    // The next clip is a fresh mount of the player, which reads exactly this.
+    expect(readSessionVolume('test:carries-over')).toEqual({ volume: 0.4, muted: false });
+  });
+
+  test('🔴 muting keeps the level underneath, so unmuting is not a jump to full', () => {
+    // *"if I unmute it, keep that value"* — a mute stored as `volume: 0` would satisfy every
+    // other test here and return him to silence on the press that asks for sound.
+    writeSessionVolume('test:muted-level', { volume: 0.4, muted: false });
+    writeSessionVolume('test:muted-level', { volume: 0.4, muted: true });
+    expect(readSessionVolume('test:muted-level')).toEqual({ volume: 0.4, muted: true });
+  });
+
+  test('a reader gets a copy — a live player cannot mutate the next one’s starting value', () => {
+    writeSessionVolume('test:copy', { volume: 0.4, muted: false });
+    const held = readSessionVolume('test:copy');
+    if (held) held.volume = 0.99;
+    expect(readSessionVolume('test:copy')?.volume).toBe(0.4);
+  });
+
+  test('the two real surfaces do not fight over one key', () => {
+    // The gallery stage and a `VideoPlayer` an app mounts on a page of its own are two
+    // players — the same reason `media/stageResize.ts` keys the remembered height. One
+    // shared key would make setting the level on either of them reach into the other.
+    expect(STAGE_VOLUME_KEY).not.toBe(PLAYER_VOLUME_KEY);
+    writeSessionVolume('test:surface-a', { volume: 0.2, muted: false });
+    expect(readSessionVolume('test:surface-b')).toBeNull();
+  });
+
+  test('a level outside 0–1 is clamped rather than handed to an element that would throw', () => {
+    // `HTMLMediaElement.volume` throws `IndexSizeError` outside 0–1, and the value arrives
+    // from a player's own event — clamping at the store is the one place every path passes.
+    writeSessionVolume('test:clamp', { volume: 4, muted: false });
+    expect(readSessionVolume('test:clamp')?.volume).toBe(1);
+    writeSessionVolume('test:clamp', { volume: -2, muted: false });
+    expect(readSessionVolume('test:clamp')?.volume).toBe(0);
+  });
+});
+
+/**
+ * 🔴 Nothing reaches a web store — that is what makes a refresh silent.
+ *
+ * `localStorage` is the obvious wrong home and `sessionStorage` is the subtle one: it is
+ * cleared when the tab closes, NOT when the page reloads, so a "session" volume put there
+ * survives the F5 he asked to return him to mute. Both are asserted, because the point of a
+ * check is to red on the change a later reader would consider an improvement.
+ */
+describe('a refresh forgets it, by construction', () => {
+  test('a write touches neither `localStorage` nor `sessionStorage`', () => {
+    const persisted = spyOn(globalThis.localStorage, 'setItem');
+    const sessioned = spyOn(globalThis.sessionStorage, 'setItem');
+    try {
+      writeSessionVolume(STAGE_VOLUME_KEY, { volume: 0.55, muted: false });
+      expect(persisted).not.toHaveBeenCalled();
+      expect(sessioned).not.toHaveBeenCalled();
+    } finally {
+      persisted.mockRestore();
+      sessioned.mockRestore();
+    }
+    // Belt and braces: neither store has an entry under that key for a reload to find.
+    expect(globalThis.localStorage.getItem(STAGE_VOLUME_KEY)).toBeNull();
+    expect(globalThis.sessionStorage.getItem(STAGE_VOLUME_KEY)).toBeNull();
+  });
+
+  test('…while the sibling preferences beside it still DO persist', () => {
+    // The guard above must not be read as "this module stopped remembering things", which is
+    // how a later reader could "fix" the inconsistency in the wrong direction. The end
+    // behavior is a way of WORKING and survives a reload on purpose; only loudness was asked
+    // to be forgotten, and the two live in one file.
+    try {
+      writePlaybackEnd('all');
+      expect(globalThis.localStorage.getItem('cbmg:playback-end')).toBe('all');
+    } finally {
+      globalThis.localStorage.removeItem('cbmg:playback-end');
+    }
+  });
+});
+
+/**
+ * 🔴 A read cannot throw, and that is not an accident of the implementation.
+ *
+ * Every other reader in this module is wrapped because `localStorage` THROWS rather than
+ * returning null in a sandboxed iframe and in Safari's private mode, and an unguarded read
+ * takes the whole gallery render down over a remembered preference. This one reaches for no
+ * storage at all, so there is nothing to be denied — asserted against a hostile environment
+ * rather than assumed, so that moving it onto a web store without a guard fails here.
+ */
+describe('a hostile storage environment', () => {
+  function withHostileStorage<T>(run: () => T): T {
+    const originals = (['sessionStorage', 'localStorage'] as const).map(
+      (name) => [name, Object.getOwnPropertyDescriptor(globalThis, name)] as const,
+    );
+    for (const [name] of originals) {
+      Object.defineProperty(globalThis, name, {
+        configurable: true,
+        get() {
+          throw new Error(`SecurityError: access to ${name} is denied`);
+        },
+      });
+    }
+    try {
+      return run();
+    } finally {
+      for (const [name, descriptor] of originals) {
+        if (descriptor) Object.defineProperty(globalThis, name, descriptor);
+      }
+    }
+  }
+
+  test('a read still answers instead of taking the render down with it', () => {
+    writeSessionVolume('test:hostile', { volume: 0.25, muted: false });
+    expect(withHostileStorage(() => readSessionVolume('test:hostile'))).toEqual({
+      volume: 0.25,
+      muted: false,
+    });
+  });
+
+  test('a write is not an error either — an unremembered volume still works this clip', () => {
+    expect(() =>
+      withHostileStorage(() => writeSessionVolume('test:hostile', { volume: 0.3, muted: false })),
+    ).not.toThrow();
+  });
+});

package/src/react/media-gallery/playbackPreferences.ts

@@ -257,3 +257,103 @@ export function writeViewMode(mode: GalleryViewMode): void {
     // Unremembered is still usable this session.
   }
 }
+
+// ── How loud, for THIS SESSION and no longer ──────────────────────────────────────────────
+
+/**
+ * The level a player opens at, and whether it opens silent.
+ *
+ * ── The owner's spec, verbatim (`ideas/collections-09-14.md`, 2026-09-14) ───────────────
+ * *"Keep the media player volume where I set it after changing it during a session except if
+ * I refresh or first log in then continue starting it at mute. Then if I unmute it, keep that
+ * value as I change to other videos."*
+ *
+ * Three rules, and the middle one is the whole design:
+ *
+ *   | fresh page load / first sign-in | muted, exactly as it is today |
+ *   | he changes it, then opens another clip | that level, for the rest of the session |
+ *   | he refreshes | muted again |
+ *
+ * ── 🔴 It is kept IN MEMORY. Not `localStorage`, and not `sessionStorage` either ────────
+ * The neighbours above are `localStorage` because they are ways of WORKING — how a folder
+ * plays through, how a stage is pinned — and a way of working survives a reload. Loudness is
+ * not: *"except if I refresh … continue starting it at mute"* is a request for this to be
+ * FORGOTTEN, so the only correct store is one that cannot outlive the page.
+ *
+ * 🔴 `sessionStorage` is NOT that store, however much its name suggests it. It is cleared
+ * when the TAB closes, not when the page loads — MDN, in as many words: *"the data survives
+ * page reloads and restores"*. Measured here 2026-09-16 in the repo's own Chromium (write,
+ * `page.reload()`, read: the value is still there), because the difference is invisible in a
+ * unit test and is precisely the row of the table above that he called out. A volume put
+ * there comes back LOUD on the one gesture he named as the one that must return to silence.
+ *
+ * A module-level `Map` dies with the document, which is what a person means by "this
+ * session". It is also why nothing here needs the `try` wrapping every reader above carries:
+ * there is no web storage to be denied by a sandboxed iframe or by Safari's private mode, and
+ * therefore no read that can throw the gallery render away over a remembered volume. The
+ * specs assert both stores stay untouched, so a later move onto one of them — which would
+ * silently restore loudness across a refresh — fails rather than passes.
+ *
+ * SSR-safe for the same reason: writes only ever happen in a browser event handler, so the
+ * map a server renders against is always empty and every server-rendered player starts muted.
+ *
+ * ── 🔴 Muted and the level are TWO facts ────────────────────────────────────────────────
+ * *"if I unmute it, keep that value"* — so a mute may not be stored as `volume: 0`. Pressing
+ * mute and pressing unmute has to leave the level where he put it, which it only does if the
+ * level survives the mute independently. Every media element already models these two
+ * separately; collapsing them here is what would break it.
+ */
+export interface SessionVolume {
+  /** 0–1: what it plays at, and what UNMUTING returns to. */
+  volume: number;
+  /** Silent — whatever level is underneath. */
+  muted: boolean;
+}
+
+/**
+ * What a player opens at when the person has not touched the volume this session: full level,
+ * no sound. It is the level that matters — a restored `volume: 1` under a mute is what makes
+ * the control bar's unmute button behave the way it did before any of this existed.
+ */
+export const DEFAULT_SESSION_VOLUME: SessionVolume = { volume: 1, muted: true };
+
+/**
+ * Where a session volume is kept — the CALLER names it, for the same reason
+ * `media/stageResize.ts` makes the remembered HEIGHT a keyed value: there is more than one
+ * player in this package, and one shared key would make setting the level on one of them
+ * silently reach into the other. The gallery stage and the shared `VideoPlayer` primitive an
+ * app mounts on a page of its own are two players.
+ */
+export const PLAYER_VOLUME_KEY = 'cbvp:volume';
+
+/** The gallery stage's own — both transports of it (Vidstack and the native `<video>`). */
+export const STAGE_VOLUME_KEY = 'cbmg:stage-volume';
+
+/** Per key, for this document only. See {@link SessionVolume} for why it is not a web store. */
+const sessionVolumes = new Map<string, SessionVolume>();
+
+/**
+ * What he set this session, or `null` for "he has not touched it".
+ *
+ * 🔴 `null` rather than {@link DEFAULT_SESSION_VOLUME}, and the distinction is load-bearing:
+ * a player that was never going to make a sound anyway (`autoPlay={false}`, which mutes
+ * nothing today) must keep behaving exactly as it did, and it only can if the caller can tell
+ * "nothing set" apart from "set to the default". Handing back the default here would silence
+ * every click-to-play consumer in the fleet on upgrade.
+ */
+export function readSessionVolume(key: string): SessionVolume | null {
+  const held = sessionVolumes.get(key);
+  // A COPY: the caller hands this to a player that will go on changing it, and a shared
+  // object would let one surface's live state leak into the next one's starting value.
+  return held ? { ...held } : null;
+}
+
+/** Remember it for the rest of this PAGE. Never longer — see {@link SessionVolume}. */
+export function writeSessionVolume(key: string, value: SessionVolume): void {
+  sessionVolumes.set(key, {
+    // Clamped here rather than at every call site: this lands on `HTMLMediaElement.volume`,
+    // which throws `IndexSizeError` outside 0–1.
+    volume: Math.min(1, Math.max(0, value.volume)),
+    muted: value.muted,
+  });
+}

package/src/react/media-gallery/types.ts

@@ -1,5 +1,6 @@
 import type { FileCategory } from 'cwip/file-kind';
 import type { ProcessingStatus } from 'cursedbelt-core/media';
+import type { VideoChapter } from '../media/videoChapters';
 
 /**
  * Sort orders the gallery header offers.
@@ -91,6 +92,25 @@ export interface MediaGalleryItem extends MediaGalleryItemMedia {
   durationSeconds?: number;
   /** Free-form tags — shown in the meta line and as filter chips when any item has them. */
   tags?: string[];
+  /**
+   * What this file IS, in the owner's own words — shown under the title on the stage.
+   *
+   * 🔴 The owner's ask, `ideas/collections-09-14.md`, 2026-09-14: *"In media galleries have an
+   * option for apps to tag media and aadd descriptions to media."* Tags were already readable
+   * here and there was no description field at all, so half of that sentence had nowhere to
+   * land even for an app that stored one.
+   *
+   * Like {@link tags} it is READ freely: an item that carries one renders it whether or not
+   * the app can write one. Authoring both is a capability — pass
+   * {@link MediaGalleryProps.onSaveMeta} and the control appears.
+   *
+   * 🔴 Deliberately NOT on the tile caption. That caption is two lines by design (see
+   * `galleryTileLine`) and is already contested between the tags and the measurement; a
+   * sentence there would either be an ellipsis or a third line on every tile in the grid.
+   * The stage has the room, and the stage is where somebody is actually reading about one
+   * file rather than scanning forty.
+   */
+  description?: string;
   /** Download href when it differs from `url` (e.g. `?download=1` variants). */
   downloadUrl?: string;
   /**
@@ -109,6 +129,20 @@ export interface MediaGalleryItem extends MediaGalleryItemMedia {
    * cannot render differently. An app that bakes its edits simply never sets this.
    */
   orientation?: { turns: 0 | 1 | 2 | 3; flipX?: boolean; flipY?: boolean };
+  /**
+   * The named sections of a video — YouTube chapters, stored by the app on its own row.
+   *
+   * 🔴 The owner's ask, 2026-09-15: *"allow putting markers on videos at points in time and
+   * giving them a title for the section for knowing what that part of the video is about, like
+   * youtube chapters."* Like {@link orientation}, this is metadata the app keeps beside the
+   * file rather than anything baked into it — a chapter costs no encode, applies the instant it
+   * is saved, and is free to be wrong.
+   *
+   * The stage passes them to the player, which draws the dividers on the scrub bar and fills
+   * its chapters menu (see `stagePlayableVideo`). Authoring them is a separate capability:
+   * pass {@link MediaGalleryProps.onSaveChapters} and the Sections control appears.
+   */
+  chapters?: VideoChapter[];
   /**
    * Lazily resolve this item's media URLs the first time a tile or stage needs them.
    * Called once per item id per gallery mount (cached); return `null` when the bytes

package/src/shippedFilesAreTracked.spec.ts

@@ -0,0 +1,69 @@
+/**
+ * 🔴 `bun publish` packs the WORKING DIRECTORY, not the git index — so a package can
+ * ship a file the repo does not have.
+ *
+ * ── What this cost, 2026-09-15 ─────────────────────────────────────────────────────
+ * The cursedbelt split (task 148) moved two integration specs into this package from
+ * `cursedbelt`. `git add -u .` stages only files git already knows about, so both were
+ * committed nowhere — and `bun run verify` was green *because they were present on disk*,
+ * which is the same reason nobody noticed. `1.0.2` went to the registry carrying two
+ * `src/` files that existed in no commit, and `git status` said `tracked-dirty=0`.
+ *
+ * "The tree is clean" and "everything that ships is committed" are different claims, and
+ * only the first one is what people actually check. npm versions are immutable, so the
+ * window to notice closes at publish time.
+ *
+ * ── Why this shape ─────────────────────────────────────────────────────────────────
+ * It asks git, for exactly the directories `package.json#files` promises to ship, which
+ * of those paths git does not track. That is narrower than "any untracked file" on
+ * purpose: scratch files, `.agent.noindex/`, a half-written script and an uncommitted
+ * lockfile are all legitimate states for a working tree and reddening on them would teach
+ * people to skip this. A file INSIDE the published surface is the only case where
+ * untracked means "about to ship something no one can review or revert".
+ *
+ * 🔴 It must run from a real checkout to mean anything, so it refuses rather than passes
+ * when `git` cannot answer — a check that silently degrades to green is worse than none.
+ */
+import { describe, expect, test } from 'bun:test';
+import { spawnSync } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import pkg from '../package.json';
+
+const repoRoot = fileURLToPath(new URL('..', import.meta.url));
+
+/** The directories `files` promises to ship, minus build output nobody commits. */
+const shippedDirs = (): string[] =>
+	((pkg as { files?: string[] }).files ?? []).filter((f) => f !== 'dist' && existsSync(`${repoRoot}/${f}`));
+
+const git = (...args: string[]): { ok: boolean; out: string } => {
+	const r = spawnSync('git', ['-C', repoRoot, ...args], { encoding: 'utf8' });
+	return { ok: r.status === 0, out: (r.stdout ?? '').trim() };
+};
+
+describe('every file inside the published surface is tracked', () => {
+	test('git can answer at all — a degraded check must refuse, not pass', () => {
+		expect(git('rev-parse', '--is-inside-work-tree').ok, 'not a git checkout, so this check proves nothing').toBe(true);
+	});
+
+	test('package.json names a shippable directory to scan', () => {
+		// Vacuity guard: an empty `files`, or one naming only `dist`, makes the assertion
+		// below pass while scanning nothing at all.
+		expect(shippedDirs().length, '`files` names no committed directory — nothing would be scanned').toBeGreaterThan(0);
+	});
+
+	test('no untracked file sits inside a directory `files` ships', () => {
+		// --others = untracked; --exclude-standard honours .gitignore, so deliberately
+		// ignored paths (.agent.noindex, node_modules) are not offences.
+		const { ok, out } = git('ls-files', '--others', '--exclude-standard', '--', ...shippedDirs());
+		expect(ok, 'git ls-files failed').toBe(true);
+		const untracked = out === '' ? [] : out.split('\n');
+		expect(
+			untracked,
+			'these would be PUBLISHED but exist in no commit — `bun publish` packs the working directory, not the index,\n' +
+				'so the registry would carry code nobody can review, diff or revert, and npm versions are immutable.\n' +
+				'Commit them (or add them to .gitignore if they genuinely must not ship):\n  ' +
+				untracked.join('\n  '),
+		).toEqual([]);
+	});
+});

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

@@ -0,0 +1,30 @@
+/*
+ * cursedbelt — the `activity-bar` area. GENERATED BUILD ARTIFACT. Never hand-edit.
+ *
+ * the `cursedbelt/react/activity-bar` rail — app chrome most apps do not mount.
+ *
+ * Every Tailwind utility the modules in this area's import closure use, MINUS the
+ * ones `styles-areas/core.css` already ships. 🔴 Import ALL of these, in
+ * this order — this file alone is incomplete:
+ *
+ *   @import "tailwindcss";
+ *   @import "cursedbelt/styles-static.css";
+ *   @import "cursedbelt/styles-areas/core.css";
+ *   @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. 72 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
+ * 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;
+  }
+}