cursedbelt 1.0.0 → 2.3.0

package/src/tapTargetStylesheet.spec.ts

@@ -0,0 +1,150 @@
+import { describe, expect, it } from 'bun:test';
+import { Scanner } from '@tailwindcss/oxide';
+import { compile } from 'tailwindcss';
+import {
+	TAP_TARGET,
+	TAP_TARGET_ALWAYS,
+	TAP_TARGET_HALO,
+	TAP_TARGET_HEIGHT,
+	TAP_TARGET_SQUARE,
+} from './react/lib/tapTarget';
+
+/**
+ * 🔴 THE TAP FLOOR SURVIVES THE JIT.
+ *
+ * `src/react/lib/tapTarget.ts` collapsed 48 hand-written copies of `DESIGN.md`
+ * §5's 44px floor — and 12 of the hover-reveal fix that goes with it — into five
+ * constants. That refactor has one failure mode, and it is silent: **Tailwind's
+ * JIT scans source TEXT, it does not evaluate code.** A
+ * class that stops being a literal inside this package's own `@source "."` glob —
+ * moved to a file the glob does not cover, assembled from a variable, split
+ * across a template it cannot read — is a class Tailwind never emits. Nothing
+ * reds. The types are fine, the build is fine, every component still carries the
+ * class name in its `className`, and the rule it names simply does not exist in
+ * the stylesheet any more. Every tap target on every phone in the fleet quietly
+ * loses its floor.
+ *
+ * So this compiles the REAL `src/styles.css` — its own `@source` directive, its
+ * own scan of this package's tree, Tailwind's own candidate extractor — and
+ * asserts the emitted CSS still carries a rule for every utility the constants
+ * name. It is the one check that can tell "the constant is exported" apart from
+ * "the constant does anything".
+ *
+ * 🔴 NOTHING IN THIS FILE MAY SPELL A TAP UTILITY OUT. The `@source` glob covers
+ * `src/`, and a spec is source: the first draft of this header quoted the height
+ * class in its own prose, and that comment alone kept the class in the candidate
+ * set after the constant had been broken. The check passed against a stylesheet
+ * held up by a sentence about the check. Utilities come from the imports above
+ * and from nowhere else in here.
+ *
+ * Verified failing, 2026-09-14, before it was trusted — each probe applied,
+ * observed and removed again:
+ *   · `TAP_TARGET_HEIGHT` rewritten as a template that interpolates its `11`
+ *       → both the extraction test and "utilities the emitted stylesheet has no
+ *         rule for: <the height class>". `TAP_TARGET` composes the same constant,
+ *         so every button in the package loses the floor from this one edit.
+ *   · `TAP_TARGET_HEIGHT` truncated to its scale-less prefix (the trailing `11`
+ *     dropped) → same failure, which is the anchored-selector half. A plain
+ *     `includes()` would have PASSED this one: the truncated name is a substring
+ *     of the rule the untruncated class emits elsewhere in the same stylesheet.
+ *     🔴 Truncating by one DIGIT instead does not fail, and should not — the
+ *     result is another real Tailwind utility with a real rule; what would be
+ *     broken there is the design, not the pipeline this file measures.
+ *   · the `@source` line removed from `src/styles.css` → "scanned no candidates",
+ *     the guard below that stops every other assertion passing vacuously.
+ *
+ * ~1.5s: one Tailwind compile of ~118 KB over ~25k candidates.
+ */
+
+const REPO_ROOT = import.meta.dir.replace(/\/src$/, '');
+
+/** Directory half of an absolute path — `node:path` is virtualized by the test preload. */
+const dirOf = (path: string): string => path.slice(0, path.lastIndexOf('/'));
+
+/**
+ * Resolve a CSS `@import` the way a bundler would.
+ *
+ * 🔴 `Bun.file`, never `node:fs`: this package's test preload virtualizes node
+ * builtins, so a `readFileSync` here would read MOCK data and the whole
+ * measurement would be of nothing (same trap as `publishShape.spec.ts`). A CSS
+ * package announces its entry through the `style` condition, not `main`.
+ */
+const loadStylesheet = async (
+	id: string,
+	base: string,
+): Promise<{ path: string; base: string; content: string }> => {
+	const read = async (path: string) => ({
+		path,
+		base: dirOf(path),
+		content: await Bun.file(path).text(),
+	});
+	if (id.startsWith('.')) return read(`${base}/${id}`);
+	const packageDir = `${REPO_ROOT}/node_modules/${id}`;
+	const manifest = (await Bun.file(`${packageDir}/package.json`).json()) as {
+		exports?: { '.'?: { style?: string } };
+		style?: string;
+		main?: string;
+	};
+	const entry = manifest.exports?.['.']?.style ?? manifest.style ?? manifest.main;
+	if (!entry) throw new Error(`no stylesheet entry for "${id}"`);
+	return read(`${packageDir}/${entry.replace(/^\.\//, '')}`);
+};
+
+/** Every utility the five constants name, deduped — the thing that must survive. */
+const UTILITIES = [
+	...new Set(
+		[TAP_TARGET_HEIGHT, TAP_TARGET, TAP_TARGET_SQUARE, TAP_TARGET_HALO, TAP_TARGET_ALWAYS]
+			.join(' ')
+			.split(/\s+/)
+			.filter(Boolean),
+	),
+];
+
+const emitted = await (async () => {
+	// An app imports Tailwind first, then this package's stylesheet — exactly the
+	// two lines `src/styles.css`'s own header tells a consumer to write.
+	const source = await Bun.file(`${REPO_ROOT}/src/styles.css`).text();
+	const compiler = await compile(`@import "tailwindcss";\n${source}`, {
+		base: `${REPO_ROOT}/src`,
+		loadStylesheet,
+	});
+	const candidates = new Scanner({ sources: compiler.sources }).scan();
+	return { candidates, css: compiler.build(candidates) };
+})();
+
+describe('the tap floor reaches the stylesheet', () => {
+	it('scanned this package for candidates at all', () => {
+		// Guards every assertion below: with no `@source` directive the scan returns
+		// nothing, `build([])` emits no utilities, and "the rule is missing" would be
+		// indistinguishable from "the refactor broke it".
+		expect(emitted.candidates.length).toBeGreaterThan(1000);
+	});
+
+	it('names utilities Tailwind actually extracted from the source text', () => {
+		// The JIT half: each class is a literal in a file the `@source` glob covers.
+		expect(UTILITIES.filter((u) => !emitted.candidates.includes(u))).toEqual([]);
+	});
+
+	it('emits a CSS rule for every utility the tap-target constants name', () => {
+		// A `:` is backslash-escaped inside a selector, so the class `a:b` is written
+		// `.a\:b` in the output — and a candidate that survived extraction but
+		// generated no rule (a utility Tailwind does not know) still fails here.
+		//
+		// 🔴 Anchored on the END of the class name, not a substring: a class truncated
+		// by one character is a prefix of the rule its untruncated self emits, so a
+		// plain `includes()` would have found it in a stylesheet that never had it.
+		const missing = UTILITIES.filter((u) => {
+			// The utility → its escaped selector text → a regex matching that text, with
+			// the CSS backslash itself escaped a second time for the regex.
+			const selectorText = `.${u.replace(/:/g, '\\:')}`;
+			const anchored = new RegExp(
+				`${selectorText.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}(?![\\w\\\\-])`,
+			);
+			return !anchored.test(emitted.css);
+		});
+		expect(
+			missing,
+			`utilities the emitted stylesheet has no rule for: ${missing.join(', ')}`,
+		).toEqual([]);
+	});
+});

package/src/testTmpRoot.spec.ts

@@ -0,0 +1,102 @@
+import { describe, expect, it } from 'bun:test';
+import { isAbsolute, resolve, sep } from 'node:path';
+import { resolveTestTmpRoot } from '../scripts/testTmpRoot';
+
+/**
+ * 🔴 THE CHECKER CANNOT SEE THIS ONE, WHICH IS WHY IT IS A TEST.
+ *
+ * `scripts/testTmpRoot.ts` is a bun test PRELOAD: it runs before the first spec in
+ * this repo, on every `bun test`, and it decides where every `mkdtemp` in the suite
+ * lands. Until 2026-09-13 it pointed `$TMPDIR` at the PREVIOUS generation's state
+ * root — 77 MB and 259 process directories had accumulated there — and
+ * `tools/check-paths.ts` reported nothing, because the path was interpolated from
+ * `$HOME` on one line and assembled from a variable on the next. Neither line
+ * carried a shape the trigger looks for.
+ *
+ * So the gate is here instead, and it asserts the RESOLVED root rather than the
+ * source text: a previous generation's directory cannot come back through a
+ * variable, a rename, or a constant without one of these failing.
+ *
+ * This spec lives in `src/` rather than beside the file it proves because
+ * `bun run test` is `bun test src` — a spec under `scripts/` would never run, and
+ * a gate that does not run is the exact failure mode above.
+ */
+
+/** Every directory name this generation must never write into. */
+const PREVIOUS_GENERATIONS = ['app-managed', 'code-retiring', 'code-active', 'Master-Docs'];
+
+const REPO_ROOT = resolve(import.meta.dir, '..');
+
+describe('the test scratch root', () => {
+  it('lives under $FORGE_STATE when the generation supplies one', () => {
+    const root = resolveTestTmpRoot({ FORGE_STATE: '/state/cursedforge' });
+    expect(root.startsWith(`/state/cursedforge${sep}`)).toBe(true);
+  });
+
+  it('falls back to this repo, never to anything derived from $HOME', () => {
+    const root = resolveTestTmpRoot({ HOME: '/home/somebody' });
+    expect(root.startsWith(`${REPO_ROOT}${sep}`)).toBe(true);
+    expect(root).not.toContain('/home/somebody');
+    // Gitignored here, so a fallback run leaves nothing for git to report.
+    expect(root).toContain('.agent.noindex');
+  });
+
+  it('treats a blank $FORGE_STATE as no $FORGE_STATE', () => {
+    expect(resolveTestTmpRoot({ FORGE_STATE: '   ', HOME: '/home/somebody' }).startsWith(`${REPO_ROOT}${sep}`)).toBe(
+      true,
+    );
+  });
+
+  /*
+   * 🔴 `.noindex` is not decoration and is not cosmetic: it is the only marker that
+   * keeps Spotlight out of files written LATER into a tree, and a test root is
+   * written to constantly (measured 43× on this machine). Both branches carry it.
+   */
+  it('keeps a .noindex segment on every branch', () => {
+    for (const env of [{ FORGE_STATE: '/state/cursedforge' }, { HOME: '/home/somebody' }]) {
+      expect(resolveTestTmpRoot(env).split(sep).some((segment) => segment.endsWith('.noindex'))).toBe(true);
+    }
+  });
+
+  it('resolves an absolute path, whatever the caller cwd is', () => {
+    for (const env of [{ FORGE_STATE: '/state/cursedforge' }, {}]) {
+      expect(isAbsolute(resolveTestTmpRoot(env))).toBe(true);
+    }
+  });
+
+  /*
+   * The assertion the whole file exists for. Note the envs that TRY to steer it
+   * back: the previous generation's own variable, and a home that already contains
+   * its folder. Neither may reach the answer.
+   */
+  it('never resolves a previous generation, whatever the environment says', () => {
+    const envs: Array<Record<string, string | undefined>> = [
+      {},
+      { HOME: '/home/somebody' },
+      { FORGE_STATE: '/state/cursedforge', HOME: '/home/somebody' },
+      { APP_MANAGED_HOME: '/nowhere/inherited', HOME: '/home/somebody' },
+      { HOME: `/home/somebody/${PREVIOUS_GENERATIONS[0]}` },
+    ];
+    for (const env of envs) {
+      const root = resolveTestTmpRoot(env);
+      for (const name of PREVIOUS_GENERATIONS) {
+        expect(root, `resolved "${root}" for env ${JSON.stringify(env)}`).not.toContain(name);
+      }
+    }
+  });
+
+  /*
+   * And the live one: whatever this very process ended up with. The preload has
+   * already run by the time any spec does, so `$TMPDIR` here is the real answer on
+   * the real machine — the measurement the source-text assertions above cannot make.
+   */
+  it('has already pointed THIS process somewhere legitimate', () => {
+    const live = process.env.TMPDIR ?? '';
+    if (process.env.TMPDIR_TEST_PASSTHROUGH) return; // a suite asked for the system root
+    for (const name of PREVIOUS_GENERATIONS) {
+      expect(live, `$TMPDIR is "${live}"`).not.toContain(name);
+    }
+    const expected = resolveTestTmpRoot();
+    expect(live.startsWith(`${expected}${sep}`)).toBe(true);
+  });
+});

package/dist/core/duplicates/index.d.ts

@@ -1,116 +0,0 @@
-/**
- * "Are these two files the same thing?" — the fleet's ONE answer, with no I/O in it.
- *
- * ── Why this is here and not in an app ──────────────────────────────────────────────────
- * `binary-server` wrote these rules first (2026-08-13, the owner: *"make strategy to always
- * check for duplicate binaries in same app for same user … mark likely the duplicates for
- * users to confirm"*), and they were measured against a real store: the copy-counter cap, the
- * camera-generic stem list and the 5% size window each exist because a wider rule proposed
- * thousands of pairs nobody could ever review. `music` then needed the same question asked of
- * a 5,400-track library — *"I want to see a duplicate next to the file that it is a possible
- * duplicate of … The 'binary-server' app (bs) already has this feature for checking duplicate
- * files. We can reuse it and enhance the customizability if needed so the main strategy is
- * shared."*
- *
- * So the strategy lives once, here, and both consume it. What each app keeps for itself is the
- * evidence only it has: bs's perceptual frame hashes, music's artist/title key.
- *
- * ── What is NOT here, deliberately ──────────────────────────────────────────────────────
- * Anything that needs a database, a filesystem, a fetch or a picture decoder. This module is
- * pure so both consumers can prove their behaviour with `bun test` instead of against a live
- * store, and so a browser bundle may import it (music renders the pair side by side).
- */
-/**
- * How far two sizes may differ and still be called the same thing.
- *
- * A re-encode at a different quality is the case this exists for, and those land within a few
- * percent. Zero would make a name match a strict subset of "same name AND same size", which
- * misses precisely the files worth asking about; much larger starts pairing a clip with its
- * own trailer.
- */
-export declare const SIZE_TOLERANCE = 0.05;
-/**
- * How far two playing times may differ and still be the same recording.
- *
- * Wide enough for a re-encode (a trim of a trailing black frame, a container that rounds), far
- * too narrow for the owner's 2026-08-14 report of a 3:56 video paired with a 1:52 one.
- */
-export declare const DURATION_TOLERANCE = 0.05;
-/**
- * The name to compare, reduced to what a human means by "the same file".
- *
- * Strips the directory, the extension, and the marks a copy picks up along the way —
- * `Finder`'s ` copy`/` copy 2`, a browser's ` (1)`, a script's `_1`/`-1` — then collapses
- * everything that is not a letter or a digit. `My Video (1).mp4`, `my_video.MP4` and
- * `My-Video copy 2.mov` all reduce to `myvideo`.
- *
- * 🔴 The extension is stripped ON PURPOSE, so a re-encode (`.mov` → `.mp4`, `.wma` → `.mp3`)
- * still pairs with its source. That is the single most common likely-duplicate in this fleet's
- * stores and a rule that kept the extension would never see one.
- *
- * 🔴 **The copy-counter strip is capped at two digits**, and that cap is a measured bug fix
- * (bs, 2026-08-14). It used to be `[-_]\d+$`, which eats a CAMERA SEQUENCE as readily as a copy
- * marker: `IMG_4595` and `IMG_4646` both reduced to `img`, so every iPhone capture in a tenant
- * shared one bucket and paired with every other one whose size was within 5%. `_1`…`_99` is
- * what a copy marker actually looks like; four digits is a photo's identity, and it must
- * survive.
- */
-export declare function normalizeName(name: string | null | undefined): string;
-/**
- * Stems that name a CAMERA, not a file.
- *
- * `IMG`, `DSC`, `PXL`, `VID` are what a device calls everything it produces; two files whose
- * names reduce to one of these have told us nothing except that they came from a phone. Even
- * with the counter cap above, `IMG_1.MOV` still reduces to `img`, and a bucket called "img" is
- * every photo the owner has ever taken.
- *
- * 🔴 This rejects a MATCH, never a file. Both copies stay wherever they are, and an
- * identical-bytes pair is unaffected — a checksum match never consults the name.
- */
-export declare const GENERIC_STEMS: ReadonlySet<string>;
-/**
- * A name that could belong to any file from that device tells us nothing about identity.
- *
- * 🔴 The trailing digit run is stripped BEFORE the lookup, and only here — never in
- * {@link normalizeName}, where removing it is what made every camera capture one bucket. The
- * two are asked at different moments: `normalizeName` decides whether two names are the SAME
- * (so `img4595` and `img4646` must stay apart), and this decides whether a name that already
- * matched is worth anything (so two files both called `Track01` have told us nothing, and a
- * ripper names half a library that).
- */
-export declare const isGenericName: (normalized: string) => boolean;
-/** Within {@link SIZE_TOLERANCE} of each other. Two zero-byte files are not "close" — they
- *  are two files nothing is known about. */
-export declare function sizesClose(a: number, b: number, tolerance?: number): boolean;
-/**
- * Within {@link DURATION_TOLERANCE} of each other.
- *
- * 🔴 A missing or zero duration answers `null`, never `false`: "nobody has measured this yet"
- * and "these are different lengths" are opposite answers, and collapsing them makes an
- * unprobed library look like a library with no duplicates in it.
- */
-export declare function durationsClose(a: number | null | undefined, b: number | null | undefined, tolerance?: number): boolean | null;
-/** One file, reduced to what this module can reason about. Units are the caller's — pass
- *  both durations in the same unit or not at all. */
-export interface NamedFileFacts {
-    /** The name a person would recognise: a display title, else the last path segment. */
-    name: string | null | undefined;
-    sizeBytes: number;
-    /** Playing time, in whatever unit the caller uses consistently. Null = never measured. */
-    duration?: number | null;
-}
-export interface NameMatchVerdict {
-    match: boolean;
-    /** Written for the owner reading a review queue, never for a log. Empty when `match` is
-     *  false — a non-match has nothing to explain. */
-    reason: string;
-}
-/**
- * The shared "these look like the same thing" test: the NAME agrees after normalization, the
- * sizes are close, and nothing about the length says otherwise.
- *
- * It is deliberately a QUESTION and never an action. Both consumers act only on a checksum,
- * which is proof; this decides what is worth showing a person side by side.
- */
-export declare function likelyTheSameFile(a: NamedFileFacts, b: NamedFileFacts): NameMatchVerdict;
-//# sourceMappingURL=index.d.ts.map

package/dist/core/duplicates/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/core/duplicates/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH;;;;;;;GAOG;AACH,eAAO,MAAM,cAAc,OAAO,CAAC;AAEnC;;;;;GAKG;AACH,eAAO,MAAM,kBAAkB,OAAO,CAAC;AAEvC;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GAAG,MAAM,CAUrE;AAED;;;;;;;;;;GAUG;AACH,eAAO,MAAM,aAAa,EAAE,WAAW,CAAC,MAAM,CAgC5C,CAAC;AAEH;;;;;;;;;GASG;AACH,eAAO,MAAM,aAAa,GAAI,YAAY,MAAM,KAAG,OAGD,CAAC;AAEnD;4CAC4C;AAC5C,wBAAgB,UAAU,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,SAAS,SAAiB,GAAG,OAAO,CAKpF;AAED;;;;;;GAMG;AACH,wBAAgB,cAAc,CAC7B,CAAC,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,EAC5B,CAAC,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,EAC5B,SAAS,SAAqB,GAC5B,OAAO,GAAG,IAAI,CAGhB;AAED;qDACqD;AACrD,MAAM,WAAW,cAAc;IAC9B,sFAAsF;IACtF,IAAI,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC;IAChC,SAAS,EAAE,MAAM,CAAC;IAClB,0FAA0F;IAC1F,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CACzB;AAED,MAAM,WAAW,gBAAgB;IAChC,KAAK,EAAE,OAAO,CAAC;IACf;sDACkD;IAClD,MAAM,EAAE,MAAM,CAAC;CACf;AAED;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAAC,CAAC,EAAE,cAAc,EAAE,CAAC,EAAE,cAAc,GAAG,gBAAgB,CAqBxF"}

package/dist/core/duplicates/index.js

@@ -1,178 +0,0 @@
-/**
- * "Are these two files the same thing?" — the fleet's ONE answer, with no I/O in it.
- *
- * ── Why this is here and not in an app ──────────────────────────────────────────────────
- * `binary-server` wrote these rules first (2026-08-13, the owner: *"make strategy to always
- * check for duplicate binaries in same app for same user … mark likely the duplicates for
- * users to confirm"*), and they were measured against a real store: the copy-counter cap, the
- * camera-generic stem list and the 5% size window each exist because a wider rule proposed
- * thousands of pairs nobody could ever review. `music` then needed the same question asked of
- * a 5,400-track library — *"I want to see a duplicate next to the file that it is a possible
- * duplicate of … The 'binary-server' app (bs) already has this feature for checking duplicate
- * files. We can reuse it and enhance the customizability if needed so the main strategy is
- * shared."*
- *
- * So the strategy lives once, here, and both consume it. What each app keeps for itself is the
- * evidence only it has: bs's perceptual frame hashes, music's artist/title key.
- *
- * ── What is NOT here, deliberately ──────────────────────────────────────────────────────
- * Anything that needs a database, a filesystem, a fetch or a picture decoder. This module is
- * pure so both consumers can prove their behaviour with `bun test` instead of against a live
- * store, and so a browser bundle may import it (music renders the pair side by side).
- */
-/**
- * How far two sizes may differ and still be called the same thing.
- *
- * A re-encode at a different quality is the case this exists for, and those land within a few
- * percent. Zero would make a name match a strict subset of "same name AND same size", which
- * misses precisely the files worth asking about; much larger starts pairing a clip with its
- * own trailer.
- */
-export const SIZE_TOLERANCE = 0.05;
-/**
- * How far two playing times may differ and still be the same recording.
- *
- * Wide enough for a re-encode (a trim of a trailing black frame, a container that rounds), far
- * too narrow for the owner's 2026-08-14 report of a 3:56 video paired with a 1:52 one.
- */
-export const DURATION_TOLERANCE = 0.05;
-/**
- * The name to compare, reduced to what a human means by "the same file".
- *
- * Strips the directory, the extension, and the marks a copy picks up along the way —
- * `Finder`'s ` copy`/` copy 2`, a browser's ` (1)`, a script's `_1`/`-1` — then collapses
- * everything that is not a letter or a digit. `My Video (1).mp4`, `my_video.MP4` and
- * `My-Video copy 2.mov` all reduce to `myvideo`.
- *
- * 🔴 The extension is stripped ON PURPOSE, so a re-encode (`.mov` → `.mp4`, `.wma` → `.mp3`)
- * still pairs with its source. That is the single most common likely-duplicate in this fleet's
- * stores and a rule that kept the extension would never see one.
- *
- * 🔴 **The copy-counter strip is capped at two digits**, and that cap is a measured bug fix
- * (bs, 2026-08-14). It used to be `[-_]\d+$`, which eats a CAMERA SEQUENCE as readily as a copy
- * marker: `IMG_4595` and `IMG_4646` both reduced to `img`, so every iPhone capture in a tenant
- * shared one bucket and paired with every other one whose size was within 5%. `_1`…`_99` is
- * what a copy marker actually looks like; four digits is a photo's identity, and it must
- * survive.
- */
-export function normalizeName(name) {
-    if (!name)
-        return "";
-    const leaf = name.split(/[\\/]/).pop() ?? "";
-    const stem = leaf.replace(/\.[a-z0-9]{1,5}$/i, "");
-    return stem
-        .toLowerCase()
-        .replace(/\s*\(\d+\)\s*$/, "")
-        .replace(/\s+copy(\s+\d+)?\s*$/, "")
-        .replace(/[-_]\d{1,2}\s*$/, "")
-        .replace(/[^a-z0-9]+/g, "");
-}
-/**
- * Stems that name a CAMERA, not a file.
- *
- * `IMG`, `DSC`, `PXL`, `VID` are what a device calls everything it produces; two files whose
- * names reduce to one of these have told us nothing except that they came from a phone. Even
- * with the counter cap above, `IMG_1.MOV` still reduces to `img`, and a bucket called "img" is
- * every photo the owner has ever taken.
- *
- * 🔴 This rejects a MATCH, never a file. Both copies stay wherever they are, and an
- * identical-bytes pair is unaffected — a checksum match never consults the name.
- */
-export const GENERIC_STEMS = new Set([
-    "img",
-    "image",
-    "images",
-    "dsc",
-    "dscf",
-    "dscn",
-    "pxl",
-    "vid",
-    "video",
-    "movie",
-    "mov",
-    "photo",
-    "pic",
-    "picture",
-    "screenshot",
-    "screenrecording",
-    "untitled",
-    "unknown",
-    "file",
-    "download",
-    "scan",
-    "capture",
-    "copy",
-    "new",
-    "temp",
-    "tmp",
-    // Music's own version of the same problem: an untagged rip is called this by every ripper
-    // ever written, and `track01` from two albums is two different songs.
-    "track",
-    "audiotrack",
-    "unknownartist",
-]);
-/**
- * A name that could belong to any file from that device tells us nothing about identity.
- *
- * 🔴 The trailing digit run is stripped BEFORE the lookup, and only here — never in
- * {@link normalizeName}, where removing it is what made every camera capture one bucket. The
- * two are asked at different moments: `normalizeName` decides whether two names are the SAME
- * (so `img4595` and `img4646` must stay apart), and this decides whether a name that already
- * matched is worth anything (so two files both called `Track01` have told us nothing, and a
- * ripper names half a library that).
- */
-export const isGenericName = (normalized) => normalized.length < 3 ||
-    GENERIC_STEMS.has(normalized) ||
-    GENERIC_STEMS.has(normalized.replace(/\d+$/, ""));
-/** Within {@link SIZE_TOLERANCE} of each other. Two zero-byte files are not "close" — they
- *  are two files nothing is known about. */
-export function sizesClose(a, b, tolerance = SIZE_TOLERANCE) {
-    if (a === b && a > 0)
-        return true;
-    const larger = Math.max(a, b);
-    if (larger <= 0)
-        return false;
-    return Math.abs(a - b) / larger <= tolerance;
-}
-/**
- * Within {@link DURATION_TOLERANCE} of each other.
- *
- * 🔴 A missing or zero duration answers `null`, never `false`: "nobody has measured this yet"
- * and "these are different lengths" are opposite answers, and collapsing them makes an
- * unprobed library look like a library with no duplicates in it.
- */
-export function durationsClose(a, b, tolerance = DURATION_TOLERANCE) {
-    if (!a || !b || a <= 0 || b <= 0)
-        return null;
-    return Math.abs(a - b) / Math.max(a, b) <= tolerance;
-}
-/**
- * The shared "these look like the same thing" test: the NAME agrees after normalization, the
- * sizes are close, and nothing about the length says otherwise.
- *
- * It is deliberately a QUESTION and never an action. Both consumers act only on a checksum,
- * which is proof; this decides what is worth showing a person side by side.
- */
-export function likelyTheSameFile(a, b) {
-    const na = normalizeName(a.name);
-    const nb = normalizeName(b.name);
-    // Two empty names are not a match with each other — it means neither file has a name worth
-    // comparing (a bare digest key, an untitled upload), and pairing those proposes every
-    // unnamed object as a duplicate of every other.
-    if (!na || na !== nb)
-        return { match: false, reason: "" };
-    if (isGenericName(na))
-        return { match: false, reason: "" };
-    if (!sizesClose(a.sizeBytes, b.sizeBytes))
-        return { match: false, reason: "" };
-    if (durationsClose(a.duration, b.duration) === false)
-        return { match: false, reason: "" };
-    const pct = Math.round((Math.abs(a.sizeBytes - b.sizeBytes) / Math.max(a.sizeBytes, b.sizeBytes, 1)) * 100);
-    return {
-        match: true,
-        reason: a.sizeBytes === b.sizeBytes
-            ? "same name, same size, different bytes"
-            : `same name, size within ${pct}%, different bytes`,
-    };
-}
-//# sourceMappingURL=index.js.map

package/dist/core/duplicates/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/core/duplicates/index.ts"],"names":[],"mappings":"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"}

package/dist/core/namespace/helpers.d.ts

@@ -1,14 +0,0 @@
-import type { Namespace } from './types';
-/**
- * Picks the next hue (0–359) for a new namespace by stepping around the color
- * wheel by the golden angle once per existing namespace, then nudging past
- * any exact collision with a hue already in use. Golden-angle stepping keeps
- * consecutive hues far apart without tracking gaps explicitly.
- */
-export declare function nextHue(existing: Namespace[]): number;
-/**
- * Trims and collapses internal whitespace in a namespace label, caps it at 40
- * characters, and rejects a label that is empty/blank after normalization.
- */
-export declare function normalizeNamespaceLabel(label: string): string;
-//# sourceMappingURL=helpers.d.ts.map

package/dist/core/namespace/helpers.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"helpers.d.ts","sourceRoot":"","sources":["../../../src/core/namespace/helpers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AAOzC;;;;;GAKG;AACH,wBAAgB,OAAO,CAAC,QAAQ,EAAE,SAAS,EAAE,GAAG,MAAM,CAOrD;AAED;;;GAGG;AACH,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAI7D"}

package/dist/core/namespace/helpers.js

@@ -1,29 +0,0 @@
-/** Irrational angle (in degrees) whose repeated steps around a 360° wheel
- * never re-align on a short cycle, so successive hues stay maximally spread
- * regardless of how many namespaces already exist. */
-const GOLDEN_ANGLE = 137.50776405003785;
-/**
- * Picks the next hue (0–359) for a new namespace by stepping around the color
- * wheel by the golden angle once per existing namespace, then nudging past
- * any exact collision with a hue already in use. Golden-angle stepping keeps
- * consecutive hues far apart without tracking gaps explicitly.
- */
-export function nextHue(existing) {
-    const used = new Set(existing.map((n) => n.hue));
-    let hue = Math.round((existing.length * GOLDEN_ANGLE) % 360);
-    while (used.has(hue)) {
-        hue = (hue + 1) % 360;
-    }
-    return hue;
-}
-/**
- * Trims and collapses internal whitespace in a namespace label, caps it at 40
- * characters, and rejects a label that is empty/blank after normalization.
- */
-export function normalizeNamespaceLabel(label) {
-    const normalized = label.trim().replace(/\s+/g, ' ').slice(0, 40);
-    if (!normalized)
-        throw new Error('namespace label must not be empty');
-    return normalized;
-}
-//# sourceMappingURL=helpers.js.map

package/dist/core/namespace/helpers.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"helpers.js","sourceRoot":"","sources":["../../../src/core/namespace/helpers.ts"],"names":[],"mappings":"AAEA;;sDAEsD;AACtD,MAAM,YAAY,GAAG,kBAAkB,CAAC;AAExC;;;;;GAKG;AACH,MAAM,UAAU,OAAO,CAAC,QAAqB;IAC3C,MAAM,IAAI,GAAG,IAAI,GAAG,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;IACjD,IAAI,GAAG,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,QAAQ,CAAC,MAAM,GAAG,YAAY,CAAC,GAAG,GAAG,CAAC,CAAC;IAC7D,OAAO,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC;QACrB,GAAG,GAAG,CAAC,GAAG,GAAG,CAAC,CAAC,GAAG,GAAG,CAAC;IACxB,CAAC;IACD,OAAO,GAAG,CAAC;AACb,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,uBAAuB,CAAC,KAAa;IACnD,MAAM,UAAU,GAAG,KAAK,CAAC,IAAI,EAAE,CAAC,OAAO,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;IAClE,IAAI,CAAC,UAAU;QAAE,MAAM,IAAI,KAAK,CAAC,mCAAmC,CAAC,CAAC;IACtE,OAAO,UAAU,CAAC;AACpB,CAAC"}

package/dist/core/namespace/index.d.ts

@@ -1,4 +0,0 @@
-export type { Namespace, NamespaceCreateInput, NamespaceStore, NamespaceUpdateInput, } from './types';
-export { nextHue, normalizeNamespaceLabel } from './helpers';
-export { createMemoryNamespaceStore } from './memoryStore';
-//# sourceMappingURL=index.d.ts.map

package/dist/core/namespace/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/core/namespace/index.ts"],"names":[],"mappings":"AAIA,YAAY,EACV,SAAS,EACT,oBAAoB,EACpB,cAAc,EACd,oBAAoB,GACrB,MAAM,SAAS,CAAC;AACjB,OAAO,EAAE,OAAO,EAAE,uBAAuB,EAAE,MAAM,WAAW,CAAC;AAC7D,OAAO,EAAE,0BAA0B,EAAE,MAAM,eAAe,CAAC"}

package/dist/core/namespace/index.js

@@ -1,6 +0,0 @@
-// `cursedbelt/namespace` — reusable flat namespace/workspace model. Pure and
-// React-free (the switcher/picker UI lives in the consuming app), so servers
-// can import the contract + store without pulling any UI runtime.
-export { nextHue, normalizeNamespaceLabel } from './helpers';
-export { createMemoryNamespaceStore } from './memoryStore';
-//# sourceMappingURL=index.js.map

package/dist/core/namespace/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/core/namespace/index.ts"],"names":[],"mappings":"AAAA,6EAA6E;AAC7E,6EAA6E;AAC7E,kEAAkE;AAQlE,OAAO,EAAE,OAAO,EAAE,uBAAuB,EAAE,MAAM,WAAW,CAAC;AAC7D,OAAO,EAAE,0BAA0B,EAAE,MAAM,eAAe,CAAC"}

package/dist/core/namespace/memoryStore.d.ts

@@ -1,19 +0,0 @@
-import type { Namespace, NamespaceCreateInput, NamespaceUpdateInput } from './types';
-/**
- * Zero-config in-memory {@link NamespaceStore}: a single per-boot `Map`, so a
- * host that wires nothing up still gets a working (non-persistent) namespace
- * list — the same role `createMemoryCategoryStore` plays. Swap in a
- * persistent store (f's `createSqliteNamespaceStore`) for real data.
- *
- * Deliberately not annotated `: NamespaceStore` — the interface allows async
- * returns, which would force callers (and these tests) to `await` values that
- * are always synchronous here. Structural typing keeps it assignable wherever
- * a `NamespaceStore` is expected.
- */
-export declare function createMemoryNamespaceStore(idFactory?: () => string, now?: () => number): {
-    list(): Namespace[];
-    create(input: NamespaceCreateInput): Namespace;
-    update(id: string, input: NamespaceUpdateInput): Namespace;
-    remove(id: string): void;
-};
-//# sourceMappingURL=memoryStore.d.ts.map