cursedbelt 4.0.0 → 4.1.0

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "cursedbelt",
-	"version": "4.0.0",
+	"version": "4.1.0",
 	"license": "ISC",
 	"type": "module",
 	"description": "The React design system of the cursedbelt split — components, styles, theme. cursedbelt-core below it; server tier in cursedbelt-server.",
@@ -45,7 +45,7 @@
 		"e2e:resize-grip": "playwright test --config e2e/playwright.config.ts resize-grip-rail.spec.ts",
 		"e2e:touch": "playwright test --config e2e/playwright.config.ts --project=touch",
 		"done:serial": "bun run typecheck && bun run lint && bun run test && bun run build",
-		"paths": "bun ../../tools/check-paths.ts .",
+		"paths": "bun run scripts/paths.ts",
 		"verify": "bun run scripts/verify.ts",
 		"prepublishOnly": "bun run verify",
 		"styles:areas": "bun run scripts/generateAreaStyles.ts"
@@ -291,6 +291,24 @@
 			"source": "./src/react/components/SelectField.tsx",
 			"import": "./dist/react/components/SelectField.js"
 		},
+		"./react/list-selection": {
+			"types": "./dist/react/hooks/useListSelection.d.ts",
+			"bun": "./src/react/hooks/useListSelection.ts",
+			"source": "./src/react/hooks/useListSelection.ts",
+			"import": "./dist/react/hooks/useListSelection.js"
+		},
+		"./react/table-sort": {
+			"types": "./dist/react/hooks/useTableSort.d.ts",
+			"bun": "./src/react/hooks/useTableSort.ts",
+			"source": "./src/react/hooks/useTableSort.ts",
+			"import": "./dist/react/hooks/useTableSort.js"
+		},
+		"./react/multi-select-field": {
+			"types": "./dist/react/components/MultiSelectField.d.ts",
+			"bun": "./src/react/components/MultiSelectField.tsx",
+			"source": "./src/react/components/MultiSelectField.tsx",
+			"import": "./dist/react/components/MultiSelectField.js"
+		},
 		"./react/sharing": {
 			"types": "./dist/react/sharing/index.d.ts",
 			"bun": "./src/react/sharing/index.ts",

package/scripts/paths.ts

@@ -0,0 +1,106 @@
+#!/usr/bin/env bun
+/**
+ * `bun run paths` — the generation's whole-tree laws, run over THIS repo's tree.
+ *
+ * {@link TOOLS} is the list: `check-paths.ts` (the one law — exactly one file in a generation
+ * may contain a literal path) and `check-doc-citations.ts` (every `docs/<name>.md` this repo
+ * points a reader at must exist, with the sections it names). Both are generation-scoped rules
+ * a repo proves about ITSELF — rule 3, a repo's gate proves that repo — both are located the
+ * same way, and both have to fail this step rather than be skipped.
+ *
+ * ## 🔴 Why this is a wrapper and not `bun ../../tools/check-paths.ts .`
+ *
+ * That spelling assumes this checkout sits at a fixed depth under the generation root, and a
+ * WORKTREE never does: the working agreement puts worktrees outside every generation by
+ * construction, under the machine-wide worktrees root. Measured 2026-09-17 in a worktree,
+ * with no changes to any script — `error: Module not found "../../tools/check-paths.ts"`,
+ * and the gate stops on its FIRST step. Seventeen packages spelled it that way, and the failure
+ * mode is not the error — it is the workaround: an agent that cannot run its repo's gate moves
+ * back into the shared checkout another agent is holding, or lands without a green gate — and
+ * the second one is invisible afterwards.
+ *
+ * {@link findForgeRoot} walks up for `forge.env`, the same marker `tools/check-paths.ts` and
+ * the runner both use, so the three cannot disagree. {@link viaWorktree} is the worktree case:
+ * a worktree's `.git` is a FILE pointing at the primary checkout's git directory, so the
+ * primary is discoverable with no environment variable and no guess.
+ *
+ * 🔴 **No generation, no pass.** Answering "fine" because the check could not be located is how
+ * a rule stops being enforced without anybody deciding to stop enforcing it — so every failure
+ * to locate exits 1, and says which of the two walks came back empty.
+ *
+ * `tools/check-paths.ts` is what keeps this spelling honest across the roster: a repo whose
+ * `paths` script reaches a tool through a relative `../` module path fails the whole-generation
+ * run, which is the check that this whole file is the fix for.
+ */
+import { spawnSync } from "node:child_process";
+import { existsSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+/** The generation's tools this repo runs over its own tree, in the order they should fail. */
+const TOOLS = ["check-paths.ts", "check-doc-citations.ts"];
+
+/** How far up either walk looks before giving up — a bound, so a misuse is `null` in ms. */
+const MAX_HOPS = 16;
+
+/** Walk up from `from` for a directory containing `marker`, or `null`. */
+function walkUp(from: string, marker: string): string | null {
+	let dir = resolve(from);
+	for (let hops = 0; hops < MAX_HOPS; hops++) {
+		if (existsSync(join(dir, marker))) return dir;
+		const up = dirname(dir);
+		if (up === dir) return null;
+		dir = up;
+	}
+	return null;
+}
+
+/** The directory holding `forge.env` above `from`, or `null` when that is not inside a generation. */
+function findForgeRoot(from: string): string | null {
+	return walkUp(from, "forge.env");
+}
+
+/** The generation above the checkout this WORKTREE was cut from, or `null` on anything unexpected. */
+function viaWorktree(from: string): string | null {
+	try {
+		const git = spawnSync("git", ["rev-parse", "--path-format=absolute", "--git-common-dir"], {
+			cwd: from,
+			encoding: "utf8",
+			timeout: 5_000,
+		});
+		if (git.status !== 0) return null;
+		const gitDir = (git.stdout ?? "").trim();
+		if (!gitDir || !gitDir.startsWith("/")) return null;
+		// `<primary>/.git` → `<primary>`, then the ordinary walk up.
+		return findForgeRoot(dirname(gitDir));
+	} catch {
+		return null;
+	}
+}
+
+const here = dirname(fileURLToPath(import.meta.url));
+/** This checkout — the nearest ancestor holding a `package.json`, so it is right in a worktree. */
+const repo = walkUp(here, "package.json");
+const root = findForgeRoot(here) ?? viaWorktree(here);
+
+if (!repo) {
+	console.error(`✗ no package.json above ${here}, so there is no repo to check.`);
+	process.exit(1);
+}
+if (!root) {
+	console.error("✗ this checkout is not inside a generation and is not a worktree of one, so");
+	console.error(`  tools/{${TOOLS.join(",")}} cannot be located. Run it from a checkout under a`);
+	console.error("  generation, or from a worktree cut from one — a skipped check is not a passed one.");
+	process.exit(1);
+}
+
+for (const name of TOOLS) {
+	const tool = join(root, "tools", name);
+	if (!existsSync(tool)) {
+		console.error(`✗ ${tool} does not exist. The generation at ${root} has no ${name},`);
+		console.error("  so this repo cannot prove it obeys that law. That is a failure, not a skip.");
+		process.exit(1);
+	}
+	const result = spawnSync("bun", [tool, repo, ...process.argv.slice(2)], { stdio: "inherit" });
+	if ((result.status ?? 1) !== 0) process.exit(result.status ?? 1);
+}

package/src/react/markdown/MarkdownDoc.spec.tsx

@@ -44,7 +44,7 @@ describe('MarkdownDoc', () => {
 
   test('javascript: and unknown-scheme links are neutralized to plain text', () => {
     const { container } = render(
-      <MarkdownDoc markdown={'[bad](javascript:alert(1)) and [weird](vbscript:x) and [ok](docs/x.md)'} />,
+      <MarkdownDoc markdown={'[bad](javascript:alert(1)) and [weird](vbscript:x) and [ok](docs/x.md)'} />, // check-doc-citations:ignore markdown fixture for the link sanitiser
     );
     const anchors = Array.from(container.querySelectorAll('a'));
     expect(anchors).toHaveLength(1);