cursedbelt-core 2.0.0 → 2.1.1

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

@@ -4,5 +4,5 @@
  * The storage + query half is `cursedbelt-server/activity`; this entry is what a
  * browser, a spec or a wire type can import without pulling `bun:sqlite` in.
  */
-export { ACTIVITY_OUTCOMES, activityFromShareEvent, activitySubject, describeActivityEvent, describeActivityResource, isActivityAction, isActivityOutcome, } from "./model";
-export type { ActivityEvent, ActivityEventInput, ActivityOutcome, ActivityResource, } from "./model";
+export { ACTIVITY_OUTCOMES, activityFromShareEvent, activitySubject, describeActivityEvent, describeActivityResource, isActivityAction, isActivityOutcome, } from "./model.js";
+export type { ActivityEvent, ActivityEventInput, ActivityOutcome, ActivityResource, } from "./model.js";

package/dist/core/activity/index.js

@@ -4,4 +4,4 @@
  * The storage + query half is `cursedbelt-server/activity`; this entry is what a
  * browser, a spec or a wire type can import without pulling `bun:sqlite` in.
  */
-export { ACTIVITY_OUTCOMES, activityFromShareEvent, activitySubject, describeActivityEvent, describeActivityResource, isActivityAction, isActivityOutcome, } from "./model";
+export { ACTIVITY_OUTCOMES, activityFromShareEvent, activitySubject, describeActivityEvent, describeActivityResource, isActivityAction, isActivityOutcome, } from "./model.js";

package/dist/core/activity/model.d.ts

@@ -30,7 +30,7 @@
  *  - **`id` is source-qualified** (`log:41`, `share:12`), because the stream is a
  *    UNION over more than one table and two tables' autoincrements collide at 1.
  */
-import type { ShareEvent } from "../sharing/model";
+import type { ShareEvent } from "../sharing/model.js";
 /** How it went. `denied` is its own outcome rather than an `error`: a refused
  *  action is the single most interesting row in an audit trail, and one that
  *  reads as a crash gets triaged as one. */
@@ -39,7 +39,7 @@ export declare const ACTIVITY_OUTCOMES: readonly ActivityOutcome[];
 export declare const isActivityOutcome: (value: unknown) => value is ActivityOutcome;
 /**
  * What was acted on: `(app, kind, id)` — deliberately identical to
- * {@link import("../sharing/model").ShareResource}, so a resource can be handed
+ * {@link import("../sharing/model.js").ShareResource}, so a resource can be handed
  * from one primitive to the other without a translation layer.
  */
 export interface ActivityResource {

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

@@ -14,5 +14,5 @@
  *
  * The React furniture that renders it lives in `cursedbelt/react/analytics`.
  */
-export * from './range';
-export * from './schedule';
+export * from './range.js';
+export * from './schedule.js';

package/dist/core/analytics/index.js

@@ -14,5 +14,5 @@
  *
  * The React furniture that renders it lives in `cursedbelt/react/analytics`.
  */
-export * from './range';
-export * from './schedule';
+export * from './range.js';
+export * from './schedule.js';

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

@@ -1,3 +1,3 @@
-export type { Category, CategoryCreateInput, CategoryNode, CategoryStore, } from './types';
-export { buildCategoryForest, categoryPath, descendantCategoryIds, flattenCategoryForest, wouldCreateCycle, } from './tree';
-export { createMemoryCategoryStore } from './memoryStore';
+export type { Category, CategoryCreateInput, CategoryNode, CategoryStore, } from './types.js';
+export { buildCategoryForest, categoryPath, descendantCategoryIds, flattenCategoryForest, wouldCreateCycle, } from './tree.js';
+export { createMemoryCategoryStore } from './memoryStore.js';

package/dist/core/category/index.js

@@ -2,5 +2,5 @@
 // through `cursedbelt/react`'s categoryTree. Pure and
 // React-free (the `TreeView` adapter lives in `cursedbelt/react`), so servers
 // can import the contract + store without pulling any UI runtime.
-export { buildCategoryForest, categoryPath, descendantCategoryIds, flattenCategoryForest, wouldCreateCycle, } from './tree';
-export { createMemoryCategoryStore } from './memoryStore';
+export { buildCategoryForest, categoryPath, descendantCategoryIds, flattenCategoryForest, wouldCreateCycle, } from './tree.js';
+export { createMemoryCategoryStore } from './memoryStore.js';

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

@@ -1,4 +1,4 @@
-import type { Category, CategoryCreateInput } from './types';
+import type { Category, CategoryCreateInput } from './types.js';
 /**
  * Zero-config in-memory {@link CategoryStore}: a per-boot `Map` per tenant, so a
  * host that wires nothing up still gets a working (non-persistent) category

package/dist/core/category/memoryStore.js

@@ -1,4 +1,4 @@
-import { wouldCreateCycle } from './tree';
+import { wouldCreateCycle } from './tree.js';
 /**
  * Zero-config in-memory {@link CategoryStore}: a per-boot `Map` per tenant, so a
  * host that wires nothing up still gets a working (non-persistent) category

package/dist/core/category/tree.d.ts

@@ -1,4 +1,4 @@
-import type { Category, CategoryNode } from './types';
+import type { Category, CategoryNode } from './types.js';
 /**
  * Would setting `childId`'s parent to `candidateParentId` create a cycle?
  * True when the candidate parent is the child itself or one of its

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

@@ -4,4 +4,4 @@
  * on app boot (before React mounts → no flash); the React control + hook live in
  * `cursedbelt/react` (`ThemeToggle`, `useColorScheme`).
  */
-export { applyColorSchemeToDocument, COLOR_SCHEME_STORAGE_KEY, type ColorSchemeMode, type ColorSchemeStorage, type ColorSchemeStore, type ColorSchemeStoreOptions, colorSchemeStore, createColorSchemeStore, getColorSchemeMode, getResolvedColorScheme, initColorScheme, type ResolvedColorScheme, setColorSchemeMode, subscribeColorScheme, toggleColorScheme, } from './colorSchemeStore';
+export { applyColorSchemeToDocument, COLOR_SCHEME_STORAGE_KEY, type ColorSchemeMode, type ColorSchemeStorage, type ColorSchemeStore, type ColorSchemeStoreOptions, colorSchemeStore, createColorSchemeStore, getColorSchemeMode, getResolvedColorScheme, initColorScheme, type ResolvedColorScheme, setColorSchemeMode, subscribeColorScheme, toggleColorScheme, } from './colorSchemeStore.js';

package/dist/core/colorScheme/index.js

@@ -4,4 +4,4 @@
  * on app boot (before React mounts → no flash); the React control + hook live in
  * `cursedbelt/react` (`ThemeToggle`, `useColorScheme`).
  */
-export { applyColorSchemeToDocument, COLOR_SCHEME_STORAGE_KEY, colorSchemeStore, createColorSchemeStore, getColorSchemeMode, getResolvedColorScheme, initColorScheme, setColorSchemeMode, subscribeColorScheme, toggleColorScheme, } from './colorSchemeStore';
+export { applyColorSchemeToDocument, COLOR_SCHEME_STORAGE_KEY, colorSchemeStore, createColorSchemeStore, getColorSchemeMode, getResolvedColorScheme, initColorScheme, setColorSchemeMode, subscribeColorScheme, toggleColorScheme, } from './colorSchemeStore.js';

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

@@ -0,0 +1,115 @@
+/**
+ * "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;

package/dist/core/duplicates/index.js

@@ -0,0 +1,177 @@
+/**
+ * "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`,
+    };
+}

package/dist/core/folder-tree/actions.d.ts

@@ -28,7 +28,7 @@
  * place that can count what is about to be lost or refuse the operation. Modelling it here
  * would mean inventing an item, and an item this model cannot see is one it cannot protect.
  */
-import type { FolderNode, FolderRemap } from "./tree";
+import type { FolderNode, FolderRemap } from "./tree.js";
 /**
  * Move everything at or under `source` INTO `destination`, and stop `source` existing.
  *

package/dist/core/folder-tree/actions.js

@@ -28,7 +28,7 @@
  * place that can count what is about to be lost or refuse the operation. Modelling it here
  * would mean inventing an item, and an item this model cannot see is one it cannot protect.
  */
-import { folderPathKey, isFolderPathUnder, parseFolderPath, serializeFolderPath, } from "./path";
+import { folderPathKey, isFolderPathUnder, parseFolderPath, serializeFolderPath, } from "./path.js";
 /**
  * Move everything at or under `source` INTO `destination`, and stop `source` existing.
  *

package/dist/core/folder-tree/index.d.ts

@@ -1,3 +1,3 @@
-export { FOLDER_PATH_DELIMITER, FOLDER_PATH_ESCAPE, folderDescendantPrefix, folderPathKey, formatFolderPath, isFolderPathUnder, isValidFolderName, normalizeFolderName, parseFolderPath, serializeFolderPath, } from "./path";
-export { buildFolderIndex, buildFolderTree, flattenFolderTree, type FolderIndex, type FolderNode, type FolderRemap, planFolderDelete, planFolderMove, planFolderRename, } from "./tree";
-export { type FolderDeleteMode, type FolderTarget, folderMoveTargets, planFolderMergeInto, } from "./actions";
+export { FOLDER_PATH_DELIMITER, FOLDER_PATH_ESCAPE, folderDescendantPrefix, folderPathKey, formatFolderPath, isFolderPathUnder, isValidFolderName, normalizeFolderName, parseFolderPath, serializeFolderPath, } from "./path.js";
+export { buildFolderIndex, buildFolderTree, flattenFolderTree, type FolderIndex, type FolderNode, type FolderRemap, planFolderDelete, planFolderMove, planFolderRename, } from "./tree.js";
+export { type FolderDeleteMode, type FolderTarget, folderMoveTargets, planFolderMergeInto, } from "./actions.js";

package/dist/core/folder-tree/index.js

@@ -15,6 +15,6 @@
 // and bulk-moved by SQL. Importing the React barrel into a Bun server to reach
 // `isFolderPathUnder` would drag `Button`/`Input` and the whole component graph into a
 // process that renders nothing. Same law as `cursedbelt-core/sharing` vs `cursedbelt/react/sharing`.
-export { FOLDER_PATH_DELIMITER, FOLDER_PATH_ESCAPE, folderDescendantPrefix, folderPathKey, formatFolderPath, isFolderPathUnder, isValidFolderName, normalizeFolderName, parseFolderPath, serializeFolderPath, } from "./path";
-export { buildFolderIndex, buildFolderTree, flattenFolderTree, planFolderDelete, planFolderMove, planFolderRename, } from "./tree";
-export { folderMoveTargets, planFolderMergeInto, } from "./actions";
+export { FOLDER_PATH_DELIMITER, FOLDER_PATH_ESCAPE, folderDescendantPrefix, folderPathKey, formatFolderPath, isFolderPathUnder, isValidFolderName, normalizeFolderName, parseFolderPath, serializeFolderPath, } from "./path.js";
+export { buildFolderIndex, buildFolderTree, flattenFolderTree, planFolderDelete, planFolderMove, planFolderRename, } from "./tree.js";
+export { folderMoveTargets, planFolderMergeInto, } from "./actions.js";

package/dist/core/folder-tree/tree.js

@@ -10,7 +10,7 @@
  * entries and for notes' groups) and keeps the dangerous part — rewriting stored
  * items — a small, testable list of string swaps.
  */
-import { folderPathKey, isFolderPathUnder, normalizeFolderName, parseFolderPath, serializeFolderPath, } from "./path";
+import { folderPathKey, isFolderPathUnder, normalizeFolderName, parseFolderPath, serializeFolderPath, } from "./path.js";
 /**
  * Build the nested tree from a flat collection of serialized folder-path strings
  * (one per item, duplicates fine). EVERY prefix becomes a node, so a tree with only

package/dist/core/master-lock/index.d.ts

@@ -8,7 +8,7 @@
  * What the whole feature is, and what it is NOT, is written once in the engine's module
  * note — read that before changing anything here.
  */
-export { MASTER_LOCK_KDF, type MasterLockKdfParams, b64u, deriveMasterLockVerifier, isMasterLockKdfParams, newMasterLockKdfParams, unb64u, } from "./kdf";
-export { BASE_DELAY_MS, DEFAULT_IDLE_MS, FREE_ATTEMPTS, MAX_DELAY_MS, MAX_IDLE_MS, MIN_IDLE_MS, clampIdleMs, delayAfter, windowRemaining, } from "./policy";
-export { MASTER_LOCK_COOKIE, masterLockCookieName, MASTER_LOCK_HEADER, MASTER_LOCK_PATHS, MASTER_LOCK_PREFIX, MASTER_LOCK_STATE_HEADER, type MasterLockAccountSummary, type MasterLockAccountsResponse, type MasterLockAddAccountRequest, type MasterLockChangeRequest, type MasterLockEditAccountRequest, type MasterLockEnrollRequest, type MasterLockHintsResponse, type MasterLockRefusal, type MasterLockSettingsRequest, type MasterLockStatus, type MasterLockUnlockRequest, } from "./wire";
-export { PRESENCE_ATTRIBUTE, type PresenceMedia, isPresenceMedia, isSomebodyWatching, } from "./presence";
+export { MASTER_LOCK_KDF, type MasterLockKdfParams, b64u, deriveMasterLockVerifier, isMasterLockKdfParams, newMasterLockKdfParams, unb64u, } from "./kdf.js";
+export { BASE_DELAY_MS, DEFAULT_IDLE_MS, FREE_ATTEMPTS, MAX_DELAY_MS, MAX_IDLE_MS, MIN_IDLE_MS, clampIdleMs, delayAfter, windowRemaining, } from "./policy.js";
+export { MASTER_LOCK_COOKIE, masterLockCookieName, MASTER_LOCK_HEADER, MASTER_LOCK_PATHS, MASTER_LOCK_PREFIX, MASTER_LOCK_STATE_HEADER, type MasterLockAccountSummary, type MasterLockAccountsResponse, type MasterLockAddAccountRequest, type MasterLockChangeRequest, type MasterLockEditAccountRequest, type MasterLockEnrollRequest, type MasterLockHintsResponse, type MasterLockRefusal, type MasterLockSettingsRequest, type MasterLockStatus, type MasterLockUnlockRequest, } from "./wire.js";
+export { PRESENCE_ATTRIBUTE, type PresenceMedia, isPresenceMedia, isSomebodyWatching, } from "./presence.js";

package/dist/core/master-lock/index.js

@@ -8,7 +8,7 @@
  * What the whole feature is, and what it is NOT, is written once in the engine's module
  * note — read that before changing anything here.
  */
-export { MASTER_LOCK_KDF, b64u, deriveMasterLockVerifier, isMasterLockKdfParams, newMasterLockKdfParams, unb64u, } from "./kdf";
-export { BASE_DELAY_MS, DEFAULT_IDLE_MS, FREE_ATTEMPTS, MAX_DELAY_MS, MAX_IDLE_MS, MIN_IDLE_MS, clampIdleMs, delayAfter, windowRemaining, } from "./policy";
-export { MASTER_LOCK_COOKIE, masterLockCookieName, MASTER_LOCK_HEADER, MASTER_LOCK_PATHS, MASTER_LOCK_PREFIX, MASTER_LOCK_STATE_HEADER, } from "./wire";
-export { PRESENCE_ATTRIBUTE, isPresenceMedia, isSomebodyWatching, } from "./presence";
+export { MASTER_LOCK_KDF, b64u, deriveMasterLockVerifier, isMasterLockKdfParams, newMasterLockKdfParams, unb64u, } from "./kdf.js";
+export { BASE_DELAY_MS, DEFAULT_IDLE_MS, FREE_ATTEMPTS, MAX_DELAY_MS, MAX_IDLE_MS, MIN_IDLE_MS, clampIdleMs, delayAfter, windowRemaining, } from "./policy.js";
+export { MASTER_LOCK_COOKIE, masterLockCookieName, MASTER_LOCK_HEADER, MASTER_LOCK_PATHS, MASTER_LOCK_PREFIX, MASTER_LOCK_STATE_HEADER, } from "./wire.js";
+export { PRESENCE_ATTRIBUTE, isPresenceMedia, isSomebodyWatching, } from "./presence.js";

package/dist/core/master-lock/wire.d.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);
  * everything else on the origin is not.

package/dist/core/media/ffmpeg.d.ts

@@ -1,4 +1,4 @@
-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 {
     videoCodec: string;

package/dist/core/media/format.d.ts

@@ -1,4 +1,4 @@
-import type { ImageOutputFormat } from './types';
+import type { ImageOutputFormat } from './types.js';
 export declare const IMAGE_OUTPUT_FORMATS: readonly ImageOutputFormat[];
 export declare function imageFormatToMime(format: ImageOutputFormat): string;
 export declare function imageFormatToExtension(format: ImageOutputFormat): string;

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

@@ -1,12 +1,12 @@
-export { type FloodFillBGOptions, floodFillBGS } from './bgRemoval';
-export { buildProbeArgs, buildThumbnailArgs, buildTrimArgs, ffmpegTimeToSeconds, type ProbeResult, parseFfmpegProgress, parseFfprobe, type VideoCodecPlan, videoCodecPlan, } from './ffmpeg';
-export { clampQuality, IMAGE_OUTPUT_FORMATS, imageFormatToExtension, imageFormatToMime, mimeToImageFormat, pickThumbnailFormat, } from './format';
-export { isAudioItem, isImageItem, isVideoItem, mediaItemAspect, mediaItemDimensions, } from './mediaItem';
-export { buildAtempoChain, buildTimelineRenderPlan, DEFAULT_NORMALIZE, type FfmpegCommand, type NormalizeSpec, type RenderPlanFile, speedFilters, type TimelineRenderOptions, type TimelineRenderPlan, } from './renderPlan';
-export { closeMask, createRegionSegmenter, DEFAULT_CLOSE_RADIUS, DEFAULT_TOLERANCE, dilateMask, downscaleRgba, erodeMask, fitWorkingSize, type ImageSegmenter, type SegmentOptions, type SegmentPrompt, type SegmentSource, sensitivityToTolerance, upscaleMask, } from './segment';
-export { formatBytes } from './size';
-export { type ClampTrimOptions, clampTrimRange, formatTimecode, type TrimRange, trimDurationSeconds, } from './trim';
-export type { GalleryMedia, GalleryPhoto, ImageOperation, ImageOutputFormat, ImagePipelineSpec, MediaItem, MediaKind, MediaKindFilter, PlayableVideo, ProcessingStatus, VideoFormat, VideoProgressEvent, VideoQuality, VideoTrimSpec, } from './types';
-export { DEFAULT_UPLOAD_CHUNK_SIZE, MAX_SINGLE_UPLOAD_BYTES } from './uploadLimits';
-export { assertValidImagePipelineSpec, assertValidVideoTrimSpec, type ValidationResult, validateImagePipelineSpec, validateVideoTrimSpec, } from './validate';
-export { cutListProblem, cutSeconds, cutTimecode, keptSeconds, keptSegments, MIN_CUT_SECONDS, normalizeCuts, type VideoCut, } from './videoCuts';
+export { type FloodFillBGOptions, floodFillBGS } from './bgRemoval.js';
+export { buildProbeArgs, buildThumbnailArgs, buildTrimArgs, ffmpegTimeToSeconds, type ProbeResult, parseFfmpegProgress, parseFfprobe, type VideoCodecPlan, videoCodecPlan, } from './ffmpeg.js';
+export { clampQuality, IMAGE_OUTPUT_FORMATS, imageFormatToExtension, imageFormatToMime, mimeToImageFormat, pickThumbnailFormat, } from './format.js';
+export { isAudioItem, isImageItem, isVideoItem, mediaItemAspect, mediaItemDimensions, } from './mediaItem.js';
+export { buildAtempoChain, buildTimelineRenderPlan, DEFAULT_NORMALIZE, type FfmpegCommand, type NormalizeSpec, type RenderPlanFile, speedFilters, type TimelineRenderOptions, type TimelineRenderPlan, } from './renderPlan.js';
+export { closeMask, createRegionSegmenter, DEFAULT_CLOSE_RADIUS, DEFAULT_TOLERANCE, dilateMask, downscaleRgba, erodeMask, fitWorkingSize, type ImageSegmenter, type SegmentOptions, type SegmentPrompt, type SegmentSource, sensitivityToTolerance, upscaleMask, } from './segment.js';
+export { formatBytes } from './size.js';
+export { type ClampTrimOptions, clampTrimRange, formatTimecode, type TrimRange, trimDurationSeconds, } from './trim.js';
+export type { GalleryMedia, GalleryPhoto, ImageOperation, ImageOutputFormat, ImagePipelineSpec, MediaItem, MediaKind, MediaKindFilter, PlayableVideo, ProcessingStatus, VideoFormat, VideoProgressEvent, VideoQuality, VideoTrimSpec, } from './types.js';
+export { DEFAULT_UPLOAD_CHUNK_SIZE, MAX_SINGLE_UPLOAD_BYTES } from './uploadLimits.js';
+export { assertValidImagePipelineSpec, assertValidVideoTrimSpec, type ValidationResult, validateImagePipelineSpec, validateVideoTrimSpec, } from './validate.js';
+export { cutListProblem, cutSeconds, cutTimecode, keptSeconds, keptSegments, MIN_CUT_SECONDS, normalizeCuts, type VideoCut, } from './videoCuts.js';

package/dist/core/media/index.js

@@ -2,17 +2,17 @@
 // the Bun server adapter (`src/server/media-bun`), the React components
 // (`cursedbelt/react/media`), and any consuming app/test. No React, no Bun, no npm
 // dep — the same module loads identically everywhere.
-export { floodFillBGS } from './bgRemoval';
-export { buildProbeArgs, buildThumbnailArgs, buildTrimArgs, ffmpegTimeToSeconds, parseFfmpegProgress, parseFfprobe, videoCodecPlan, } from './ffmpeg';
-export { clampQuality, IMAGE_OUTPUT_FORMATS, imageFormatToExtension, imageFormatToMime, mimeToImageFormat, pickThumbnailFormat, } from './format';
-export { isAudioItem, isImageItem, isVideoItem, mediaItemAspect, mediaItemDimensions, } from './mediaItem';
-export { buildAtempoChain, buildTimelineRenderPlan, DEFAULT_NORMALIZE, speedFilters, } from './renderPlan';
-export { closeMask, createRegionSegmenter, DEFAULT_CLOSE_RADIUS, DEFAULT_TOLERANCE, dilateMask, downscaleRgba, erodeMask, fitWorkingSize, sensitivityToTolerance, upscaleMask, } from './segment';
-export { formatBytes } from './size';
-export { clampTrimRange, formatTimecode, trimDurationSeconds, } from './trim';
-export { DEFAULT_UPLOAD_CHUNK_SIZE, MAX_SINGLE_UPLOAD_BYTES } from './uploadLimits';
-export { assertValidImagePipelineSpec, assertValidVideoTrimSpec, validateImagePipelineSpec, validateVideoTrimSpec, } from './validate';
+export { floodFillBGS } from './bgRemoval.js';
+export { buildProbeArgs, buildThumbnailArgs, buildTrimArgs, ffmpegTimeToSeconds, parseFfmpegProgress, parseFfprobe, videoCodecPlan, } from './ffmpeg.js';
+export { clampQuality, IMAGE_OUTPUT_FORMATS, imageFormatToExtension, imageFormatToMime, mimeToImageFormat, pickThumbnailFormat, } from './format.js';
+export { isAudioItem, isImageItem, isVideoItem, mediaItemAspect, mediaItemDimensions, } from './mediaItem.js';
+export { buildAtempoChain, buildTimelineRenderPlan, DEFAULT_NORMALIZE, speedFilters, } from './renderPlan.js';
+export { closeMask, createRegionSegmenter, DEFAULT_CLOSE_RADIUS, DEFAULT_TOLERANCE, dilateMask, downscaleRgba, erodeMask, fitWorkingSize, sensitivityToTolerance, upscaleMask, } from './segment.js';
+export { formatBytes } from './size.js';
+export { clampTrimRange, formatTimecode, trimDurationSeconds, } from './trim.js';
+export { DEFAULT_UPLOAD_CHUNK_SIZE, MAX_SINGLE_UPLOAD_BYTES } from './uploadLimits.js';
+export { assertValidImagePipelineSpec, assertValidVideoTrimSpec, validateImagePipelineSpec, validateVideoTrimSpec, } 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
 // binary-server job that runs it all read the same rules from here.
-export { cutListProblem, cutSeconds, cutTimecode, keptSeconds, keptSegments, MIN_CUT_SECONDS, normalizeCuts, } from './videoCuts';
+export { cutListProblem, cutSeconds, cutTimecode, keptSeconds, keptSegments, MIN_CUT_SECONDS, normalizeCuts, } from './videoCuts.js';

package/dist/core/media/mediaItem.d.ts

@@ -1,4 +1,4 @@
-import type { MediaItem } from './types';
+import type { MediaItem } from './types.js';
 export declare const isImageItem: (item: MediaItem) => boolean;
 export declare const isVideoItem: (item: MediaItem) => boolean;
 export declare const isAudioItem: (item: MediaItem) => boolean;

package/dist/core/media/renderPlan.d.ts

@@ -1,5 +1,5 @@
 import { type TimelineTrack } from 'cwip/timeline';
-import type { VideoFormat, VideoQuality } from './types';
+import type { VideoFormat, VideoQuality } from './types.js';
 /** An auxiliary text file the executor writes before running the commands. */
 export interface RenderPlanFile {
     name: string;

package/dist/core/media/renderPlan.js

@@ -15,7 +15,7 @@
 // end-to-end in timeline order, so close gaps before exporting if you want cuts
 // where the gaps were. Audio clip offsets are their absolute `timelineStart`.
 import { clipDuration, roundSeconds } from 'cwip/timeline';
-import { videoCodecPlan } from './ffmpeg';
+import { videoCodecPlan } from './ffmpeg.js';
 /** 720p30 keeps in-browser (wasm) export times tolerable; hosts can raise it. */
 export const DEFAULT_NORMALIZE = {
     width: 1280,

package/dist/core/media/validate.d.ts

@@ -1,4 +1,4 @@
-import type { ImagePipelineSpec, VideoTrimSpec } from './types';
+import type { ImagePipelineSpec, VideoTrimSpec } from './types.js';
 export interface ValidationResult {
     valid: boolean;
     errors: string[];

package/dist/core/media/validate.js

@@ -1,7 +1,7 @@
 // Pure spec validation — catches a malformed pipeline/trim spec BEFORE it reaches
 // sharp or ffmpeg (where the failure mode is an opaque native error). No deps;
 // `validate*` returns a collected error list, `assert*` throws on the first problem.
-import { IMAGE_OUTPUT_FORMATS } from './format';
+import { IMAGE_OUTPUT_FORMATS } from './format.js';
 function ok(errors) {
     return { valid: errors.length === 0, errors };
 }

package/dist/core/navigation/coverageTest.d.ts

@@ -1,4 +1,4 @@
-import type { NavigationModel } from './navigationModel';
+import type { NavigationModel } from './navigationModel.js';
 /**
  * Build the coverage assertion for `model` against `allRoutePaths` (the app's full
  * route list, e.g. derived from `routes.tsx`). The returned `() => void` throws —