cursedbelt-core 2.0.0 → 2.1.1

package/src/core/colorScheme/colorScheme.spec.ts

@@ -4,7 +4,7 @@ import {
   type ColorSchemeStorage,
   createColorSchemeStore,
   type ResolvedColorScheme,
-} from './index';
+} from './index.js';
 
 const makeStorage = (): ColorSchemeStorage & { map: Map<string, string> } => {
   const map = new Map<string, string>();

package/src/core/colorScheme/index.ts

@@ -20,4 +20,4 @@ export {
   setColorSchemeMode,
   subscribeColorScheme,
   toggleColorScheme,
-} from './colorSchemeStore';
+} from './colorSchemeStore.js';

package/src/core/download.spec.ts

@@ -1,5 +1,5 @@
 import { describe, expect, test } from 'bun:test';
-import { base64ToBytes, downloadBlob } from './download';
+import { base64ToBytes, downloadBlob } from './download.js';
 
 describe('base64ToBytes', () => {
   test('decodes base64 to the original bytes', () => {

package/src/core/duplicates/index.spec.ts

@@ -0,0 +1,116 @@
+/**
+ * The shared duplicate rules, proved against the cases that produced them.
+ *
+ * Every assertion here is a measured incident from `binary-server` or `music`, not an
+ * invented example — see the module header for which.
+ */
+import { describe, expect, it } from "bun:test";
+import {
+	DURATION_TOLERANCE,
+	durationsClose,
+	isGenericName,
+	likelyTheSameFile,
+	normalizeName,
+	SIZE_TOLERANCE,
+	sizesClose,
+} from "./index.js";
+
+describe("normalizeName", () => {
+	it("reduces the marks a copy picks up to the same stem", () => {
+		expect(normalizeName("My Video (1).mp4")).toBe("myvideo");
+		expect(normalizeName("my_video.MP4")).toBe("myvideo");
+		expect(normalizeName("My-Video copy 2.mov")).toBe("myvideo");
+	});
+
+	it("strips the extension, so a re-encode still pairs with its source", () => {
+		expect(normalizeName("Song.wma")).toBe(normalizeName("Song.mp3"));
+	});
+
+	it("🔴 keeps a four-digit camera sequence — the 2026-08-14 flood", () => {
+		// `IMG_4595` and `IMG_4646` must NOT collapse onto each other.
+		expect(normalizeName("IMG_4595.MOV")).not.toBe(normalizeName("IMG_4646.MOV"));
+		// …while a two-digit copy marker still does.
+		expect(normalizeName("mix_2.mp3")).toBe(normalizeName("mix.mp3"));
+	});
+
+	it("drops the directory", () => {
+		expect(normalizeName("Main 1/rap/Song.mp3")).toBe("song");
+	});
+});
+
+describe("isGenericName", () => {
+	it("rejects the stems that name a device rather than a file", () => {
+		expect(isGenericName(normalizeName("IMG_1.MOV"))).toBe(true);
+		expect(isGenericName(normalizeName("Track01.mp3"))).toBe(true);
+		expect(isGenericName(normalizeName("Between U.mp3"))).toBe(false);
+	});
+});
+
+describe("sizesClose", () => {
+	it("accepts a re-encode and refuses a different file", () => {
+		expect(sizesClose(10_000_000, 10_400_000)).toBe(true);
+		expect(sizesClose(10_000_000, 20_000_000)).toBe(false);
+	});
+
+	it("🔴 two zero-byte files are not close — nothing is known about either", () => {
+		expect(sizesClose(0, 0)).toBe(false);
+	});
+
+	it("is bounded by the exported tolerance", () => {
+		expect(sizesClose(100, 100 * (1 + SIZE_TOLERANCE))).toBe(true);
+		expect(sizesClose(100, 100 * (1 + SIZE_TOLERANCE * 2))).toBe(false);
+	});
+});
+
+describe("durationsClose", () => {
+	it("🔴 answers null when nobody has measured, never false", () => {
+		expect(durationsClose(null, 200)).toBeNull();
+		expect(durationsClose(0, 200)).toBeNull();
+		expect(durationsClose(undefined, undefined)).toBeNull();
+	});
+
+	it("refuses the owner's 3:56-vs-1:52 pair", () => {
+		expect(durationsClose(236, 112)).toBe(false);
+		expect(durationsClose(236, 236 * (1 + DURATION_TOLERANCE / 2))).toBe(true);
+	});
+});
+
+describe("likelyTheSameFile", () => {
+	const facts = (name: string, sizeBytes: number, duration?: number | null) => ({
+		name,
+		sizeBytes,
+		...(duration === undefined ? {} : { duration }),
+	});
+
+	it("pairs a re-encode of the same song", () => {
+		const verdict = likelyTheSameFile(
+			facts("Between U.mp3", 8_000_000, 312),
+			facts("Between U.wma", 7_800_000, 312),
+		);
+		expect(verdict.match).toBe(true);
+		expect(verdict.reason).toContain("same name");
+	});
+
+	it("does not pair two different songs of a similar size", () => {
+		expect(likelyTheSameFile(facts("A.mp3", 8_000_000), facts("B.mp3", 8_010_000)).match).toBe(
+			false,
+		);
+	});
+
+	it("🔴 a length that disagrees kills a name+size match", () => {
+		expect(
+			likelyTheSameFile(facts("Set.mp3", 8_000_000, 236), facts("Set.mp3", 8_100_000, 112)).match,
+		).toBe(false);
+	});
+
+	it("🔴 an unmeasured length does not — that would find nothing in an unprobed library", () => {
+		expect(
+			likelyTheSameFile(facts("Set.mp3", 8_000_000, null), facts("Set.mp3", 8_100_000, null)).match,
+		).toBe(true);
+	});
+
+	it("refuses a generic stem, and refuses two nameless files", () => {
+		expect(likelyTheSameFile(facts("IMG_1.MOV", 500), facts("IMG_1.MOV", 500)).match).toBe(false);
+		expect(likelyTheSameFile(facts("", 500), facts("", 500)).match).toBe(false);
+	});
+});

package/src/core/duplicates/index.ts

@@ -0,0 +1,203 @@
+/**
+ * "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: string | null | undefined): string {
+	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: ReadonlySet<string> = 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: string): boolean =>
+	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: number, b: number, tolerance = SIZE_TOLERANCE): boolean {
+	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: number | null | undefined,
+	b: number | null | undefined,
+	tolerance = DURATION_TOLERANCE,
+): boolean | null {
+	if (!a || !b || a <= 0 || b <= 0) return null;
+	return Math.abs(a - b) / Math.max(a, b) <= tolerance;
+}
+
+/** 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 function likelyTheSameFile(a: NamedFileFacts, b: NamedFileFacts): NameMatchVerdict {
+	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`,
+	};
+}

package/src/core/events/ccEventBus.spec.ts

@@ -1,5 +1,5 @@
 import { describe, expect, it } from 'bun:test';
-import { createCcEventBus, MAX_EVENT_DEPTH } from './ccEventBus';
+import { createCcEventBus, MAX_EVENT_DEPTH } from './ccEventBus.js';
 
 describe('CCEventBus', () => {
   it('delivers to every subscriber of a type and to nobody else', async () => {

package/src/core/file-tree/fileTreeModel.spec.ts

@@ -13,7 +13,7 @@ import {
   resolveDrop,
   resolveKeyboardMove,
   describeDrop,
-} from './fileTreeModel';
+} from './fileTreeModel.js';
 
 /**
  * The shape collections actually feeds this: albums at the top level, each one a folder,

package/src/core/folder-tree/actions.spec.ts

@@ -9,8 +9,8 @@
  * both are pinned here side by side rather than each in isolation.
  */
 import { describe, expect, test } from "bun:test";
-import { folderMoveTargets, planFolderMergeInto } from "./actions";
-import { buildFolderTree, planFolderMove } from "./tree";
+import { folderMoveTargets, planFolderMergeInto } from "./actions.js";
+import { buildFolderTree, planFolderMove } from "./tree.js";
 
 const PATHS = [
 	"rock",

package/src/core/folder-tree/actions.ts

@@ -34,8 +34,8 @@ import {
 	isFolderPathUnder,
 	parseFolderPath,
 	serializeFolderPath,
-} from "./path";
-import type { FolderNode, FolderRemap } from "./tree";
+} from "./path.js";
+import type { FolderNode, FolderRemap } from "./tree.js";
 
 /**
  * Move everything at or under `source` INTO `destination`, and stop `source` existing.

package/src/core/folder-tree/index.ts

@@ -26,7 +26,7 @@ export {
 	normalizeFolderName,
 	parseFolderPath,
 	serializeFolderPath,
-} from "./path";
+} from "./path.js";
 export {
 	buildFolderIndex,
 	buildFolderTree,
@@ -37,10 +37,10 @@ export {
 	planFolderDelete,
 	planFolderMove,
 	planFolderRename,
-} from "./tree";
+} from "./tree.js";
 export {
 	type FolderDeleteMode,
 	type FolderTarget,
 	folderMoveTargets,
 	planFolderMergeInto,
-} from "./actions";
+} from "./actions.js";

package/src/core/folder-tree/path.spec.ts

@@ -7,7 +7,7 @@ import {
 	isValidFolderName,
 	parseFolderPath,
 	serializeFolderPath,
-} from "./path";
+} from "./path.js";
 
 describe("folder path serialization", () => {
 	test("round-trips a simple nested path", () => {

package/src/core/folder-tree/tree.spec.ts

@@ -7,7 +7,7 @@ import {
 	planFolderDelete,
 	planFolderMove,
 	planFolderRename,
-} from "./tree";
+} from "./tree.js";
 
 /** A compact "name(child,child)" view of a subtree, for readable assertions. */
 function shape(nodes: readonly FolderNode[]): string {

package/src/core/folder-tree/tree.ts

@@ -17,7 +17,7 @@ import {
 	normalizeFolderName,
 	parseFolderPath,
 	serializeFolderPath,
-} from "./path";
+} from "./path.js";
 
 /** A node in the derived tree. `path` is the full segment array from the root; a
  *  `child` node's path is its parent's plus one segment. */

package/src/core/master-lock/index.ts

@@ -16,7 +16,7 @@ export {
 	isMasterLockKdfParams,
 	newMasterLockKdfParams,
 	unb64u,
-} from "./kdf";
+} from "./kdf.js";
 export {
 	BASE_DELAY_MS,
 	DEFAULT_IDLE_MS,
@@ -27,7 +27,7 @@ export {
 	clampIdleMs,
 	delayAfter,
 	windowRemaining,
-} from "./policy";
+} from "./policy.js";
 export {
 	MASTER_LOCK_COOKIE,
 	masterLockCookieName,
@@ -46,10 +46,10 @@ export {
 	type MasterLockSettingsRequest,
 	type MasterLockStatus,
 	type MasterLockUnlockRequest,
-} from "./wire";
+} from "./wire.js";
 export {
 	PRESENCE_ATTRIBUTE,
 	type PresenceMedia,
 	isPresenceMedia,
 	isSomebodyWatching,
-} from "./presence";
+} from "./presence.js";

package/src/core/master-lock/kdf.spec.ts

@@ -17,8 +17,8 @@ import {
 	deriveMasterLockVerifier,
 	isMasterLockKdfParams,
 	newMasterLockKdfParams,
-} from ".";
-import { b64u, unb64u } from "./kdf";
+} from "./index.js";
+import { b64u, unb64u } from "./kdf.js";
 
 // The exact fixture `apps/vault/src/crypto/kdf.test.ts` derives against.
 const FIXED: MasterLockKdfParams = {

package/src/core/master-lock/presence.spec.ts

@@ -10,7 +10,7 @@
  * hole it was asked to close.
  */
 import { describe, expect, test } from "bun:test";
-import { PRESENCE_ATTRIBUTE, type PresenceMedia, isPresenceMedia, isSomebodyWatching } from "./presence";
+import { PRESENCE_ATTRIBUTE, type PresenceMedia, isPresenceMedia, isSomebodyWatching } from "./presence.js";
 
 const media = (over: Partial<PresenceMedia> & { presence?: string } = {}): PresenceMedia => ({
 	paused: false,

package/src/core/master-lock/wire.spec.ts

@@ -9,7 +9,7 @@
  * it was told to mount and the browser would fetch what it was told to fetch.
  */
 import { describe, expect, it } from "bun:test";
-import { MASTER_LOCK_PATHS, MASTER_LOCK_PREFIX } from "./wire";
+import { MASTER_LOCK_PATHS, MASTER_LOCK_PREFIX } from "./wire.js";
 
 describe("MASTER_LOCK_PATHS", () => {
 	it("keeps every surface under the one prefix the guard reserves", () => {

package/src/core/master-lock/wire.ts

@@ -4,7 +4,7 @@
  * One module both halves import, so a rename cannot make the browser talk to a route that
  * no longer exists.
  */
-import type { MasterLockKdfParams } from "./kdf";
+import type { MasterLockKdfParams } from "./kdf.js";
 
 /**
  * The mount prefix. Everything under it is reachable while LOCKED (it is how you unlock);

package/src/core/media/bgRemoval.spec.ts

@@ -1,5 +1,5 @@
 import { describe, expect, test } from 'bun:test';
-import { floodFillBGS } from './bgRemoval';
+import { floodFillBGS } from './bgRemoval.js';
 
 /** Build a `w×h` RGB buffer from a `pick(x,y) → [r,g,b]` function. */
 function rgb(

package/src/core/media/ffmpeg.spec.ts

@@ -7,8 +7,8 @@ import {
   parseFfmpegProgress,
   parseFfprobe,
   videoCodecPlan,
-} from './ffmpeg';
-import type { VideoTrimSpec } from './types';
+} from './ffmpeg.js';
+import type { VideoTrimSpec } from './types.js';
 
 const trim = (over: Partial<VideoTrimSpec> = {}): VideoTrimSpec => ({
   inputPath: '/in.mp4',

package/src/core/media/ffmpeg.ts

@@ -3,7 +3,7 @@
 // (`server/media-bun/video.ts` spawns these against native ffmpeg) and the browser editor
 // (`react/media` executes the same argv against ffmpeg.wasm). Unit tested without ffmpeg.
 
-import type { VideoFormat, VideoProgressEvent, VideoQuality, VideoTrimSpec } from './types';
+import type { VideoFormat, VideoProgressEvent, VideoQuality, VideoTrimSpec } from './types.js';
 
 /** Codec + rate-control plan for an output container at a quality preset. */
 export interface VideoCodecPlan {

package/src/core/media/format.spec.ts

@@ -5,7 +5,7 @@ import {
   imageFormatToMime,
   mimeToImageFormat,
   pickThumbnailFormat,
-} from './format';
+} from './format.js';
 
 describe('format helpers', () => {
   test('mime + extension lookup', () => {

package/src/core/media/format.ts

@@ -1,7 +1,7 @@
 // Pure format helpers — MIME/extension lookup, quality clamping, thumbnail-format
 // selection. No npm deps; shared by the server adapter, the React layer, and tests.
 
-import type { ImageOutputFormat } from './types';
+import type { ImageOutputFormat } from './types.js';
 
 export const IMAGE_OUTPUT_FORMATS: readonly ImageOutputFormat[] = ['jpeg', 'png', 'webp', 'avif'];
 

package/src/core/media/index.ts

@@ -3,7 +3,7 @@
 // (`cursedbelt/react/media`), and any consuming app/test. No React, no Bun, no npm
 // dep — the same module loads identically everywhere.
 
-export { type FloodFillBGOptions, floodFillBGS } from './bgRemoval';
+export { type FloodFillBGOptions, floodFillBGS } from './bgRemoval.js';
 export {
   buildProbeArgs,
   buildThumbnailArgs,
@@ -14,7 +14,7 @@ export {
   parseFfprobe,
   type VideoCodecPlan,
   videoCodecPlan,
-} from './ffmpeg';
+} from './ffmpeg.js';
 export {
   clampQuality,
   IMAGE_OUTPUT_FORMATS,
@@ -22,14 +22,14 @@ export {
   imageFormatToMime,
   mimeToImageFormat,
   pickThumbnailFormat,
-} from './format';
+} from './format.js';
 export {
   isAudioItem,
   isImageItem,
   isVideoItem,
   mediaItemAspect,
   mediaItemDimensions,
-} from './mediaItem';
+} from './mediaItem.js';
 export {
   buildAtempoChain,
   buildTimelineRenderPlan,
@@ -40,7 +40,7 @@ export {
   speedFilters,
   type TimelineRenderOptions,
   type TimelineRenderPlan,
-} from './renderPlan';
+} from './renderPlan.js';
 export {
   closeMask,
   createRegionSegmenter,
@@ -56,15 +56,15 @@ export {
   type SegmentSource,
   sensitivityToTolerance,
   upscaleMask,
-} from './segment';
-export { formatBytes } from './size';
+} from './segment.js';
+export { formatBytes } from './size.js';
 export {
   type ClampTrimOptions,
   clampTrimRange,
   formatTimecode,
   type TrimRange,
   trimDurationSeconds,
-} from './trim';
+} from './trim.js';
 export type {
   GalleryMedia,
   GalleryPhoto,
@@ -80,15 +80,15 @@ export type {
   VideoProgressEvent,
   VideoQuality,
   VideoTrimSpec,
-} from './types';
-export { DEFAULT_UPLOAD_CHUNK_SIZE, MAX_SINGLE_UPLOAD_BYTES } from './uploadLimits';
+} from './types.js';
+export { DEFAULT_UPLOAD_CHUNK_SIZE, MAX_SINGLE_UPLOAD_BYTES } from './uploadLimits.js';
 export {
   assertValidImagePipelineSpec,
   assertValidVideoTrimSpec,
   type ValidationResult,
   validateImagePipelineSpec,
   validateVideoTrimSpec,
-} from './validate';
+} from './validate.js';
 
 // Marking sections of a video to CUT OUT. Framework-free on purpose: the dialog
 // (`react/media/VideoCutEditor`), the app route that refuses an unexecutable list and the
@@ -102,4 +102,4 @@ export {
   MIN_CUT_SECONDS,
   normalizeCuts,
   type VideoCut,
-} from './videoCuts';
+} from './videoCuts.js';

package/src/core/media/mediaItem.spec.ts

@@ -5,8 +5,8 @@ import {
   isVideoItem,
   mediaItemAspect,
   mediaItemDimensions,
-} from './mediaItem';
-import type { MediaItem } from './types';
+} from './mediaItem.js';
+import type { MediaItem } from './types.js';
 
 const item = (over: Partial<MediaItem> = {}): MediaItem => ({
   id: '1',