@aesonford/renami 0.2.2

package/renami.mjs

@@ -0,0 +1,2738 @@
+#!/usr/bin/env node
+
+// src/core/types.ts
+var DEFAULT_SETTINGS = {
+  pattern: "{name}",
+  sequence: {
+    sortBy: "dateTaken",
+    direction: "asc",
+    start: 1,
+    step: 1,
+    digits: 3,
+    restartPerFolder: false,
+    restartEvery: "never",
+    keepGroupsTogether: true
+  },
+  findReplace: [],
+  cleanup: {
+    caseMode: "none",
+    spacesToUnderscores: false,
+    lowercaseExtension: false,
+    stripDiacritics: false,
+    asciiOnly: false,
+    extensionRules: []
+  },
+  move: { destinationRoot: null },
+  dates: { setModified: false, setCreated: false, shiftMinutes: 0, useNameDate: true },
+  filter: {
+    includeSubfolders: false,
+    extensions: null,
+    mode: "files",
+    name: { text: "", regex: false },
+    minBytes: null,
+    maxBytes: null,
+    modifiedFrom: null,
+    modifiedTo: null
+  }
+};
+var isMoving = (kind) => kind === "rename" || kind === "move" || kind === "cross-drive-move";
+var hasPlannedDates = (d) => d.modified !== void 0 || d.created !== void 0;
+
+// src/core/scanner.ts
+import { lstat, readdir, stat } from "node:fs/promises";
+import path from "node:path";
+
+// src/core/names.ts
+var collator = new Intl.Collator("en", { numeric: true, sensitivity: "base" });
+function splitName(fileName2) {
+  const dot = fileName2.lastIndexOf(".");
+  if (dot <= 0 || dot === fileName2.length - 1) return { stem: fileName2, ext: "" };
+  return { stem: fileName2.slice(0, dot), ext: fileName2.slice(dot + 1) };
+}
+function nameKey(name) {
+  return name.normalize("NFC").toLowerCase();
+}
+function naturalCompare(a, b) {
+  const c = collator.compare(a, b);
+  if (c !== 0) return c;
+  return a < b ? -1 : a > b ? 1 : 0;
+}
+function lastSegment(p) {
+  const parts = p.split(/[\\/]+/).filter((s) => s !== "");
+  return parts[parts.length - 1] ?? "";
+}
+
+// src/core/scanner.ts
+var STAT_CONCURRENCY = 32;
+var SYSTEM_FILES = /* @__PURE__ */ new Set([".ds_store", "thumbs.db", "desktop.ini"]);
+var isSkipped = (name) => name.startsWith(".") || SYSTEM_FILES.has(name.toLowerCase());
+var extOf = (file) => splitName(path.basename(file)).ext.toLowerCase();
+var pad = (n2) => String(n2).padStart(2, "0");
+function localDateString(ms) {
+  const d = new Date(ms);
+  return `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())}`;
+}
+function nameMatcher(filter) {
+  if (!filter || filter.text === "") return () => true;
+  if (filter.regex) {
+    try {
+      const re = new RegExp(filter.text, "i");
+      return (name) => re.test(name);
+    } catch {
+    }
+  }
+  const needle = filter.text.toLowerCase();
+  return (name) => name.toLowerCase().includes(needle);
+}
+function passesFilters(entry, opts) {
+  if (!entry.isDir) {
+    if (opts.minBytes != null && entry.size < opts.minBytes) return false;
+    if (opts.maxBytes != null && entry.size > opts.maxBytes) return false;
+  }
+  if (opts.modifiedFrom || opts.modifiedTo) {
+    const day = localDateString(entry.mtimeMs);
+    if (opts.modifiedFrom && day < opts.modifiedFrom) return false;
+    if (opts.modifiedTo && day > opts.modifiedTo) return false;
+  }
+  return true;
+}
+async function toEntry(filePath, isDir) {
+  const st = await stat(filePath);
+  const base = path.basename(filePath);
+  const { stem, ext } = isDir ? { stem: base, ext: "" } : splitName(base);
+  return {
+    path: filePath,
+    dir: path.dirname(filePath),
+    stem,
+    ext,
+    size: st.size,
+    mtimeMs: st.mtimeMs,
+    birthtimeMs: Number.isFinite(st.birthtimeMs) && st.birthtimeMs > 0 ? st.birthtimeMs : null,
+    dev: st.dev,
+    isDir
+  };
+}
+async function walk(dir, recurse, found, unreadable) {
+  let dirents;
+  try {
+    dirents = await readdir(dir, { withFileTypes: true });
+  } catch {
+    unreadable.push(dir);
+    return;
+  }
+  await Promise.all(
+    dirents.map(async (d) => {
+      if (isSkipped(d.name) || d.isSymbolicLink()) return;
+      const full = path.join(dir, d.name);
+      if (d.isFile()) found.add(full);
+      else if (d.isDirectory() && recurse) await walk(full, true, found, unreadable);
+    })
+  );
+}
+async function listSubfolders(dir, found, unreadable) {
+  let dirents;
+  try {
+    dirents = await readdir(dir, { withFileTypes: true });
+  } catch {
+    unreadable.push(dir);
+    return;
+  }
+  for (const d of dirents) {
+    if (isSkipped(d.name) || d.isSymbolicLink()) continue;
+    if (d.isDirectory()) found.add(path.join(dir, d.name));
+  }
+}
+async function scan(paths, opts, onProgress) {
+  const folders = opts.mode === "folders";
+  const found = /* @__PURE__ */ new Set();
+  const unreadable = [];
+  for (const raw of paths) {
+    const p = path.resolve(raw);
+    let st;
+    try {
+      st = await lstat(p);
+    } catch {
+      continue;
+    }
+    if (st.isSymbolicLink() || isSkipped(path.basename(p))) continue;
+    if (folders) {
+      if (st.isDirectory()) await listSubfolders(p, found, unreadable);
+    } else if (st.isFile()) {
+      found.add(p);
+    } else if (st.isDirectory()) {
+      await walk(p, opts.includeSubfolders, found, unreadable);
+    }
+  }
+  const all = [...found].sort(naturalCompare);
+  const extensionsFound = folders ? [] : [...new Set(all.map(extOf))].sort();
+  const wanted = folders || opts.extensions === null ? null : new Set(opts.extensions.map((e) => e.toLowerCase()));
+  const matches = nameMatcher(opts.name);
+  const selected = all.filter((f) => (wanted === null || wanted.has(extOf(f))) && matches(path.basename(f)));
+  const stats = new Array(selected.length).fill(null);
+  let next = 0;
+  let done = 0;
+  const worker = async () => {
+    while (next < selected.length) {
+      const i = next++;
+      try {
+        const entry = await toEntry(selected[i], folders);
+        if (passesFilters(entry, opts)) stats[i] = entry;
+      } catch {
+      }
+      done += 1;
+      onProgress?.(done, selected.length);
+    }
+  };
+  await Promise.all(Array.from({ length: Math.min(STAT_CONCURRENCY, selected.length) }, worker));
+  const entries = stats.filter((e) => e !== null);
+  return { entries, extensionsFound, unreadableFolders: unreadable.sort(naturalCompare) };
+}
+
+// src/core/metadata/reader.ts
+import { availableParallelism } from "node:os";
+import { ExifTool } from "exiftool-vendored";
+
+// src/core/nameDate.ts
+var YEAR_MIN = 2e3;
+var YEAR_MAX = 2099;
+var TIMESTAMP = /(?<!\d)(\d{4})([-_.:]?)(\d{2})\2(\d{2})(?:[ T_\-.]| at )(\d{2})[-_.:h]?(\d{2})[-_.:m]?(\d{2})(?:\d{3})?(?!\d)/;
+var DATE_ONLY = /(?<!\d)(\d{4})([-_.]?)(\d{2})\2(\d{2})(?!\d)/;
+var n = (s) => Number(s ?? NaN);
+function validDate(year, month, day) {
+  return year >= YEAR_MIN && year <= YEAR_MAX && month >= 1 && month <= 12 && day >= 1 && day <= 31;
+}
+function dateFromName(stem) {
+  const full = TIMESTAMP.exec(stem);
+  if (full) {
+    const [year, month, day, hour, minute, second] = [n(full[1]), n(full[3]), n(full[4]), n(full[5]), n(full[6]), n(full[7])];
+    if (validDate(year, month, day) && hour <= 23 && minute <= 59 && second <= 59) {
+      return { year, month, day, hour, minute, second };
+    }
+  }
+  const date2 = DATE_ONLY.exec(stem);
+  if (date2) {
+    const [year, month, day] = [n(date2[1]), n(date2[3]), n(date2[4])];
+    if (validDate(year, month, day)) return { year, month, day, hour: 0, minute: 0, second: 0 };
+  }
+  return null;
+}
+
+// src/core/wallclock.ts
+var formatters = /* @__PURE__ */ new Map();
+function formatterFor(timeZone) {
+  let f = formatters.get(timeZone);
+  if (!f) {
+    f = new Intl.DateTimeFormat("en-US", {
+      timeZone,
+      year: "numeric",
+      month: "2-digit",
+      day: "2-digit",
+      hour: "2-digit",
+      minute: "2-digit",
+      second: "2-digit",
+      hourCycle: "h23"
+    });
+    formatters.set(timeZone, f);
+  }
+  return f;
+}
+function systemTimeZone() {
+  return Intl.DateTimeFormat().resolvedOptions().timeZone;
+}
+function instantToWallClock(ms, timeZone) {
+  const parts = formatterFor(timeZone).formatToParts(new Date(ms));
+  const get = (type) => Number(parts.find((p) => p.type === type)?.value ?? NaN);
+  return {
+    year: get("year"),
+    month: get("month"),
+    day: get("day"),
+    hour: get("hour"),
+    minute: get("minute"),
+    second: get("second")
+  };
+}
+function utcWallToZone(wall, timeZone) {
+  const ms = Date.UTC(wall.year, wall.month - 1, wall.day, wall.hour, wall.minute, wall.second);
+  const out = instantToWallClock(ms, timeZone);
+  if (wall.millisecond !== void 0) out.millisecond = wall.millisecond;
+  return out;
+}
+function wallClockToLocalDate(wc) {
+  return new Date(wc.year, wc.month - 1, wc.day, wc.hour, wc.minute, wc.second, wc.millisecond ?? 0);
+}
+function compareWallClock(a, b) {
+  return a.year - b.year || a.month - b.month || a.day - b.day || a.hour - b.hour || a.minute - b.minute || a.second - b.second || (a.millisecond ?? 0) - (b.millisecond ?? 0);
+}
+var EXIF_DATE = /^(\d{4})[:-](\d{2})[:-](\d{2})[ T](\d{2}):(\d{2}):(\d{2})(?:\.(\d+))?\s*(Z|[+-]\d{2}:?\d{2})?$/;
+function parseExifDateTime(raw) {
+  if (typeof raw !== "string") return null;
+  const m = EXIF_DATE.exec(raw.trim());
+  if (!m) return null;
+  const n2 = (i) => Number(m[i]);
+  const wall = { year: n2(1), month: n2(2), day: n2(3), hour: n2(4), minute: n2(5), second: n2(6) };
+  if (wall.year === 0 || wall.month < 1 || wall.month > 12 || wall.day < 1 || wall.day > 31 || wall.hour > 23 || wall.minute > 59 || wall.second > 59) {
+    return null;
+  }
+  const fraction = m[7];
+  if (fraction !== void 0) wall.millisecond = Number(fraction.padEnd(3, "0").slice(0, 3));
+  const tz = m[8];
+  let offsetMinutes = null;
+  if (tz === "Z") {
+    offsetMinutes = 0;
+  } else if (tz) {
+    const sign = tz.startsWith("-") ? -1 : 1;
+    const digits = tz.slice(1).replace(":", "");
+    offsetMinutes = sign * (Number(digits.slice(0, 2)) * 60 + Number(digits.slice(2, 4)));
+  }
+  return { wall, offsetMinutes };
+}
+
+// src/core/dates.ts
+function resolveDate(meta, kind) {
+  if (kind === "date_taken" && meta.dateTaken) {
+    return { value: meta.dateTaken, source: "taken", fellBack: false };
+  }
+  if (kind === "date_taken" && meta.nameDate) {
+    return { value: meta.nameDate, source: "name", fellBack: true };
+  }
+  if (kind !== "modified" && meta.created) {
+    return { value: meta.created, source: "created", fellBack: kind !== "created" };
+  }
+  return { value: meta.modified, source: "modified", fellBack: kind !== "modified" };
+}
+function sortKeyToDateKind(key) {
+  switch (key) {
+    case "dateTaken":
+      return "date_taken";
+    case "created":
+      return "created";
+    case "modified":
+      return "modified";
+    case "name":
+      return null;
+    case "manual":
+      return null;
+  }
+}
+function fallbackMessage(kind, source) {
+  const missing = kind === "date_taken" ? "No date taken" : "No created date";
+  const used = source === "name" ? "the date in its name" : source === "created" ? "created date" : "modified date";
+  return `${missing} in this file; used ${used}`;
+}
+function fsMetadata(entry, timeZone) {
+  const meta = { modified: instantToWallClock(entry.mtimeMs, timeZone) };
+  if (entry.birthtimeMs !== null && entry.birthtimeMs > 0) {
+    meta.created = instantToWallClock(entry.birthtimeMs, timeZone);
+  }
+  const nameDate = dateFromName(entry.stem);
+  if (nameDate) meta.nameDate = nameDate;
+  return meta;
+}
+function shiftWallClock(wc, minutes) {
+  const ms = Date.UTC(wc.year, wc.month - 1, wc.day, wc.hour, wc.minute, wc.second) + minutes * 6e4;
+  const d = new Date(ms);
+  const out = {
+    year: d.getUTCFullYear(),
+    month: d.getUTCMonth() + 1,
+    day: d.getUTCDate(),
+    hour: d.getUTCHours(),
+    minute: d.getUTCMinutes(),
+    second: d.getUTCSeconds()
+  };
+  if (wc.millisecond !== void 0) out.millisecond = wc.millisecond;
+  return out;
+}
+function effectiveMetadata(meta, adjust) {
+  if (adjust.shiftMinutes === 0 && adjust.useNameDate) return meta;
+  const out = { ...meta };
+  if (!adjust.useNameDate) delete out.nameDate;
+  if (adjust.shiftMinutes !== 0 && out.dateTaken) out.dateTaken = shiftWallClock(out.dateTaken, adjust.shiftMinutes);
+  return out;
+}
+
+// src/core/metadata/normalize.ts
+var VIDEO_EXTENSIONS = /* @__PURE__ */ new Set(["mov", "mp4", "m4v"]);
+var AUDIO_EXTENSIONS = /* @__PURE__ */ new Set(["mp3", "flac", "m4a", "m4b"]);
+function str(v) {
+  if (typeof v === "number" && Number.isFinite(v)) return String(v);
+  if (typeof v !== "string") return void 0;
+  const t = v.trim();
+  return t === "" ? void 0 : t;
+}
+function num(v) {
+  const n2 = typeof v === "number" ? v : typeof v === "string" ? Number.parseFloat(v) : NaN;
+  return Number.isFinite(n2) ? n2 : void 0;
+}
+function leadingInt(v) {
+  const n2 = typeof v === "number" ? Math.trunc(v) : typeof v === "string" ? Number.parseInt(v, 10) : NaN;
+  return Number.isFinite(n2) && n2 > 0 ? n2 : void 0;
+}
+function yearOf(v) {
+  if (v === void 0 || v === null) return void 0;
+  const m = /\d{4}/.exec(String(v));
+  return m ? Number(m[0]) : void 0;
+}
+function signed(value, ref, negativeRef) {
+  const n2 = num(value);
+  if (n2 === void 0) return void 0;
+  return n2 > 0 && String(ref ?? "").toUpperCase().startsWith(negativeRef) ? -n2 : n2;
+}
+function kbps(v) {
+  const n2 = num(v);
+  return n2 === void 0 ? void 0 : Math.round(n2 / 1e3);
+}
+function withSubSec(wall, subSec) {
+  if (!wall || wall.millisecond !== void 0) return wall;
+  const digits = typeof subSec === "number" ? String(subSec) : typeof subSec === "string" ? subSec.trim() : "";
+  if (!/^\d+$/.test(digits)) return wall;
+  return { ...wall, millisecond: Number(digits.padEnd(3, "0").slice(0, 3)) };
+}
+var asRecorded = (v) => parseExifDateTime(v)?.wall;
+function fromUtc(v, timeZone) {
+  const parsed2 = parseExifDateTime(v);
+  if (!parsed2) return void 0;
+  return parsed2.offsetMinutes === null ? utcWallToZone(parsed2.wall, timeZone) : parsed2.wall;
+}
+function normalizeTags(raw, entry, timeZone) {
+  const meta = fsMetadata(entry, timeZone);
+  const ext = entry.ext.toLowerCase();
+  const isVideo = VIDEO_EXTENSIONS.has(ext);
+  const isAudio = AUDIO_EXTENSIONS.has(ext);
+  const fields = {
+    dateTaken: isAudio ? void 0 : isVideo ? asRecorded(raw.CreationDate) ?? fromUtc(raw.CreateDate, timeZone) : asRecorded(raw.SubSecDateTimeOriginal) ?? withSubSec(asRecorded(raw.DateTimeOriginal), raw.SubSecTimeOriginal) ?? asRecorded(raw.CreateDate),
+    cameraMake: str(raw.Make),
+    cameraModel: str(raw.Model),
+    lens: str(raw.LensModel) ?? str(raw.LensID) ?? str(raw.Lens),
+    iso: num(raw.ISO),
+    focalLength: num(raw.FocalLength),
+    width: num(raw.ImageWidth),
+    height: num(raw.ImageHeight),
+    gpsLat: signed(raw.GPSLatitude, raw.GPSLatitudeRef, "S"),
+    gpsLon: signed(raw.GPSLongitude, raw.GPSLongitudeRef, "W"),
+    durationSeconds: num(raw.Duration),
+    artist: str(raw.Artist),
+    albumArtist: str(raw.AlbumArtist) ?? str(raw.Albumartist) ?? str(raw.Band),
+    album: str(raw.Album),
+    title: str(raw.Title),
+    genre: str(raw.Genre),
+    track: leadingInt(raw.Track) ?? leadingInt(raw.TrackNumber),
+    disc: leadingInt(raw.DiscNumber) ?? leadingInt(raw.DiskNumber) ?? leadingInt(raw.PartOfSet),
+    year: isAudio ? yearOf(raw.Year) ?? yearOf(raw.RecordingTime) ?? yearOf(raw.ContentCreateDate) ?? yearOf(raw.Date) : void 0,
+    aperture: num(raw.FNumber) ?? num(raw.ApertureValue),
+    exposureSeconds: num(raw.ExposureTime),
+    frameRate: num(raw.VideoFrameRate),
+    bitrateKbps: kbps(raw.AvgBitrate) ?? kbps(raw.AudioBitrate),
+    composer: str(raw.Composer),
+    readError: str(raw.Error)
+  };
+  const out = { ...meta };
+  for (const [key, value] of Object.entries(fields)) {
+    if (value !== void 0) out[key] = value;
+  }
+  return out;
+}
+
+// src/core/metadata/reader.ts
+var EMBEDDED_JPEG_TAGS = ["JpgFromRaw", "PreviewImage", "ThumbnailImage"];
+var READ_ARGS = ["-fast", "-n", "-api", "QuickTimeUTC=0"];
+var MetadataReader = class {
+  cache = /* @__PURE__ */ new Map();
+  exiftool;
+  timeZone;
+  constructor(opts = {}) {
+    this.exiftool = opts.exiftool ?? null;
+    this.timeZone = opts.timeZone ?? systemTimeZone();
+  }
+  tool() {
+    this.exiftool ??= new ExifTool({
+      maxProcs: Math.max(1, Math.min(4, availableParallelism() - 1)),
+      taskTimeoutMillis: 3e4
+    });
+    return this.exiftool;
+  }
+  async read(entry) {
+    if (entry.isDir) return fsMetadata(entry, this.timeZone);
+    const key = `${entry.size}:${entry.mtimeMs}`;
+    const hit = this.cache.get(entry.path);
+    if (hit && hit.key === key) return hit.meta;
+    const meta = await this.readUncached(entry);
+    this.cache.set(entry.path, { key, meta });
+    return meta;
+  }
+  async readUncached(entry) {
+    let lastError;
+    for (let attempt = 0; attempt < 2; attempt += 1) {
+      try {
+        const raw = await this.tool().readRaw(entry.path, { readArgs: READ_ARGS });
+        return normalizeTags(raw, entry, this.timeZone);
+      } catch (e) {
+        lastError = e;
+      }
+    }
+    const message2 = lastError instanceof Error ? lastError.message : String(lastError);
+    return { ...fsMetadata(entry, this.timeZone), readError: message2 };
+  }
+  /**
+   * Reads every entry, `concurrency` at a time. If a callback throws, no more files start; the
+   * files already open finish, and then this rejects with the first error.
+   */
+  async readAll(entries, onProgress, concurrency = 8, opts = {}) {
+    const result = /* @__PURE__ */ new Map();
+    let next = 0;
+    let done = 0;
+    const errors = [];
+    const worker = async () => {
+      try {
+        while (next < entries.length && errors.length === 0 && !opts.signal?.aborted) {
+          const entry = entries[next];
+          next += 1;
+          if (!entry) continue;
+          const meta = await this.read(entry);
+          result.set(entry.path, meta);
+          opts.onResult?.(entry.path, meta);
+          done += 1;
+          onProgress?.(done, entries.length);
+        }
+      } catch (e) {
+        errors.push(e);
+      }
+    };
+    await Promise.all(Array.from({ length: Math.min(concurrency, entries.length) }, worker));
+    if (errors.length > 0) throw errors[0];
+    return result;
+  }
+  /**
+   * The largest JPEG a RAW file carries, for the preview panel, with the RAW file's
+   * orientation. Null when it has none.
+   */
+  async embeddedJpeg(path9) {
+    const tool = this.tool();
+    for (const tag of EMBEDDED_JPEG_TAGS) {
+      try {
+        const data = await tool.extractBinaryTagToBuffer(tag, path9);
+        if (data.length === 0) continue;
+        const raw = await tool.readRaw(path9, { readArgs: ["-n", "-Orientation"] }).catch(() => ({}));
+        const o = Number(raw.Orientation);
+        return { data, orientation: Number.isInteger(o) && o >= 1 && o <= 8 ? o : 1 };
+      } catch {
+      }
+    }
+    return null;
+  }
+  async end() {
+    await this.exiftool?.end();
+    this.exiftool = null;
+  }
+  /**
+   * Tells a broken ExifTool process apart from files ExifTool simply can't read: a run of
+   * `readError`s might mean a crashed/hung ExifTool, or it might just be a run of empty or
+   * missing files. Resolves true when the vendored ExifTool responds to `version()`, false when
+   * it throws.
+   */
+  async isWorking() {
+    try {
+      await this.tool().version();
+      return true;
+    } catch {
+      return false;
+    }
+  }
+};
+
+// src/core/planner.ts
+import nodePath from "node:path";
+
+// src/core/cleanup.ts
+var EDGE_START = /^[_\- .]+/;
+var EDGE_END = /[_\- .]+$/;
+var INVALID_CHARS = /[<>:"/\\|?*\u0000-\u001f]/g;
+var REPEATED_SEPARATOR = /([_\- .])\1+/g;
+var TRAILING_DOTS_SPACES = /[. ]+$/;
+var RESERVED = /^(con|prn|aux|nul|com[1-9]|lpt[1-9])(?=\.|$)/i;
+var SPECIAL_LETTERS = {
+  "\xDF": "ss",
+  "\xE6": "ae",
+  "\xC6": "Ae",
+  "\u0153": "oe",
+  "\u0152": "Oe",
+  "\xF8": "o",
+  "\xD8": "O",
+  "\u0111": "d",
+  "\u0110": "D",
+  "\u0142": "l",
+  "\u0141": "L",
+  "\xFE": "th",
+  "\xDE": "Th",
+  "\xF0": "d",
+  "\xD0": "D",
+  "\u0131": "i"
+};
+var SPECIAL = /[ßæÆœŒøØđĐłŁþÞðÐı]/g;
+function stripDiacritics(text2) {
+  return text2.normalize("NFD").replace(new RegExp("\\p{M}+", "gu"), "").replace(SPECIAL, (ch) => SPECIAL_LETTERS[ch] ?? ch);
+}
+function asciiOnly(text2) {
+  return stripDiacritics(text2).replace(/[^\x20-\x7e]/g, "_");
+}
+var WORD_SPLIT = /[\s_\-.]+/;
+var capitalize = (w) => w.charAt(0).toUpperCase() + w.slice(1);
+function applyCase(text2, mode) {
+  const words = text2.split(WORD_SPLIT).filter((w) => w !== "");
+  switch (mode) {
+    case "none":
+      return text2;
+    case "lower":
+      return text2.toLowerCase();
+    case "upper":
+      return text2.toUpperCase();
+    case "title":
+      return text2.toLowerCase().replace(new RegExp("(^|[\\s_\\-.])(\\p{L})", "gu"), (_m, sep, ch) => sep + ch.toUpperCase());
+    case "sentence":
+      return text2.toLowerCase().replace(new RegExp("\\p{L}", "u"), (ch) => ch.toUpperCase());
+    case "snake":
+      return words.length === 0 ? text2 : words.map((w) => w.toLowerCase()).join("_");
+    case "kebab":
+      return words.length === 0 ? text2 : words.map((w) => w.toLowerCase()).join("-");
+    case "camel":
+      return words.length === 0 ? text2 : words.map((w, i) => i === 0 ? w.toLowerCase() : capitalize(w.toLowerCase())).join("");
+  }
+}
+function utf8Bytes(s) {
+  return Buffer.byteLength(s, "utf8");
+}
+function cleanSegment(parts, opts) {
+  const first = parts.findIndex((p) => p.text !== "");
+  if (first === -1) return "";
+  let last = parts.length - 1;
+  while (last > first && parts[last]?.text === "") last -= 1;
+  let text2 = parts.slice(first, last + 1).map((p) => p.text).join("");
+  if (parts.slice(0, first).some((p) => p.token)) text2 = text2.replace(EDGE_START, "");
+  if (parts.slice(last + 1).some((p) => p.token)) text2 = text2.replace(EDGE_END, "");
+  if (opts.asciiOnly) text2 = asciiOnly(text2);
+  else if (opts.stripDiacritics) text2 = stripDiacritics(text2);
+  text2 = applyCase(text2, opts.caseMode);
+  if (opts.spacesToUnderscores) text2 = text2.replace(/ /g, "_");
+  text2 = text2.replace(INVALID_CHARS, "_");
+  text2 = text2.replace(REPEATED_SEPARATOR, "$1");
+  text2 = text2.replace(TRAILING_DOTS_SPACES, "");
+  text2 = text2.normalize("NFC");
+  text2 = text2.replace(RESERVED, "$1_");
+  return text2;
+}
+
+// src/core/extensions.ts
+function normalizeExtension(text2) {
+  return text2.trim().replace(/^\.+/, "").toLowerCase();
+}
+function applyExtensionRules(ext, rules, lowercase) {
+  const key = ext.toLowerCase();
+  const rule = rules.find((r) => {
+    const from = normalizeExtension(r.from);
+    return from !== "" && from === key;
+  });
+  if (rule) return normalizeExtension(rule.to);
+  return lowercase ? key : ext;
+}
+
+// src/core/findReplace.ts
+function escapeRegExp(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function validateRules(rules) {
+  for (const [i, rule] of rules.entries()) {
+    if (!rule.regex || rule.find === "") continue;
+    try {
+      new RegExp(rule.find);
+    } catch (e) {
+      return `Find & replace rule ${i + 1}: ${e.message}`;
+    }
+  }
+  return null;
+}
+function applyFindReplace(stem, rules) {
+  let out = stem;
+  for (const rule of rules) {
+    if (rule.find === "") continue;
+    const flags = rule.matchCase ? "g" : "gi";
+    if (rule.regex) {
+      out = out.replace(new RegExp(rule.find, flags), rule.replace);
+    } else {
+      out = out.replace(new RegExp(escapeRegExp(rule.find), flags), () => rule.replace);
+    }
+  }
+  return out;
+}
+function rulesFor(rules, scope) {
+  return rules.filter((r) => (r.scope ?? "original") === scope);
+}
+
+// src/core/groups.ts
+var TIERS = [
+  ["nef", "cr2", "cr3", "arw", "dng"],
+  ["heic", "jpg", "jpeg"],
+  ["mov", "mp4", "m4v"]
+];
+function extensionTier(ext) {
+  const e = ext.toLowerCase();
+  const i = TIERS.findIndex((tier) => tier.includes(e));
+  return i === -1 ? TIERS.length : i;
+}
+function byTier(a, b) {
+  const ea = a.ext.toLowerCase();
+  const eb = b.ext.toLowerCase();
+  return extensionTier(ea) - extensionTier(eb) || (ea < eb ? -1 : ea > eb ? 1 : 0);
+}
+function choosePrimary(members, getMeta) {
+  const ordered = [...members].sort(byTier);
+  const first = ordered[0];
+  if (!first) throw new Error("choosePrimary called with no members");
+  return ordered.find((m) => getMeta(m).dateTaken !== void 0) ?? first;
+}
+function buildGroups(entries, getMeta, keepTogether) {
+  if (!keepTogether) return entries.map((e) => ({ id: e.path, members: [e], primary: e }));
+  const byKey = /* @__PURE__ */ new Map();
+  for (const e of entries) {
+    const key = `${e.dir}\0${nameKey(e.stem)}`;
+    const list = byKey.get(key);
+    if (list) list.push(e);
+    else byKey.set(key, [e]);
+  }
+  return [...byKey.values()].map((members) => {
+    const primary = choosePrimary(members, getMeta);
+    return {
+      id: members.length === 1 ? primary.path : `group:${primary.path}`,
+      members: [...members].sort(byTier),
+      primary
+    };
+  });
+}
+
+// src/core/sequencer.ts
+var fileName = (g) => g.primary.ext ? `${g.primary.stem}.${g.primary.ext}` : g.primary.stem;
+function sortGroups(groups, getMeta, sortBy, direction = "asc", manualOrder = []) {
+  const kind = sortKeyToDateKind(sortBy);
+  const rank = new Map(manualOrder.map((p, i) => [p, i]));
+  const rankOf = (g) => Math.min(...g.members.map((m) => rank.get(m.path) ?? Infinity));
+  const keyed = groups.map((g) => ({
+    g,
+    date: kind ? resolveDate(getMeta(g.primary), kind).value : null,
+    rank: sortBy === "manual" ? rankOf(g) : 0
+  }));
+  const compare = (a, b) => {
+    if (a.date && b.date) {
+      const c = compareWallClock(a.date, b.date);
+      if (c !== 0) return c;
+    } else if (sortBy === "name") {
+      const c = naturalCompare(fileName(a.g), fileName(b.g));
+      if (c !== 0) return c;
+    } else if (sortBy === "manual") {
+      if (a.rank !== b.rank) return a.rank < b.rank ? -1 : 1;
+    }
+    return naturalCompare(a.g.primary.path, b.g.primary.path);
+  };
+  const sign = direction === "desc" ? -1 : 1;
+  keyed.sort((a, b) => sign * compare(a, b));
+  return keyed.map((k) => k.g);
+}
+function period(date2, every) {
+  if (date2 === null || every === "never") return "";
+  if (every === "year") return String(date2.year);
+  if (every === "month") return `${date2.year}-${date2.month}`;
+  return `${date2.year}-${date2.month}-${date2.day}`;
+}
+function assignSequence(sorted, opts, dateOf) {
+  const step = opts.step ?? 1;
+  const every = opts.restartEvery ?? "never";
+  const next = /* @__PURE__ */ new Map();
+  const result = /* @__PURE__ */ new Map();
+  for (const g of sorted) {
+    const folder = opts.restartPerFolder ? g.primary.dir : "";
+    const bucket = `${folder}\0${every === "never" ? "" : period(dateOf?.(g) ?? null, every)}`;
+    const n2 = next.get(bucket) ?? opts.start;
+    result.set(g.id, n2);
+    next.set(bucket, n2 + step);
+  }
+  return result;
+}
+
+// src/core/template/tokens.ts
+var text = (label, get) => ({
+  kind: "text",
+  label,
+  get
+});
+var num2 = (label, digitsFormat, get, defaultDigits = () => 0) => ({ kind: "number", label, digitsFormat, get, defaultDigits });
+var date = (kind, label) => ({ kind: "date", date: kind, label });
+function formatDuration(seconds) {
+  const total = Math.round(seconds);
+  const h = Math.floor(total / 3600);
+  const m = Math.floor(total % 3600 / 60);
+  const s = String(total % 60).padStart(2, "0");
+  return h > 0 ? `${h}h${String(m).padStart(2, "0")}m${s}s` : `${m}m${s}s`;
+}
+var UNITS = ["KB", "MB", "GB", "TB"];
+function formatSize(bytes) {
+  if (bytes < 1024) return `${Math.round(bytes)}B`;
+  let value = bytes / 1024;
+  let i = 0;
+  while (value >= 1024 && i < UNITS.length - 1) {
+    value /= 1024;
+    i += 1;
+  }
+  const rounded = value >= 100 ? Math.round(value) : Math.round(value * 10) / 10;
+  return `${rounded}${UNITS[i]}`;
+}
+var trimNumber = (n2, decimals = 2) => String(Math.round(n2 * 10 ** decimals) / 10 ** decimals);
+function formatExposure(seconds) {
+  return seconds >= 1 ? `${trimNumber(seconds)}s` : `1-${Math.round(1 / seconds)}`;
+}
+function parentFolder(dir) {
+  const parts = dir.split(/[\\/]+/).filter((s) => s !== "");
+  return parts.length >= 2 ? parts[parts.length - 2] : void 0;
+}
+var TOKENS = {
+  name: text("name", (c) => c.name),
+  folder: text("folder name", (c) => lastSegment(c.entry.dir)),
+  date_taken: date("date_taken", "date taken"),
+  created: date("created", "created date"),
+  modified: date("modified", "modified date"),
+  seq: num2("sequence number", true, (c) => c.seq, (c) => c.defaultDigits),
+  camera_make: text("camera make", (c) => c.meta.cameraMake),
+  camera_model: text("camera model", (c) => c.meta.cameraModel),
+  lens: text("lens", (c) => c.meta.lens),
+  iso: num2("ISO", false, (c) => c.meta.iso),
+  focal_length: text("focal length", (c) => c.meta.focalLength === void 0 ? void 0 : `${Math.round(c.meta.focalLength)}mm`),
+  width: num2("width", false, (c) => c.meta.width),
+  height: num2("height", false, (c) => c.meta.height),
+  gps_lat: text("GPS latitude", (c) => c.meta.gpsLat?.toFixed(4)),
+  gps_lon: text("GPS longitude", (c) => c.meta.gpsLon?.toFixed(4)),
+  duration: text("duration", (c) => c.meta.durationSeconds === void 0 ? void 0 : formatDuration(c.meta.durationSeconds)),
+  artist: text("artist", (c) => c.meta.artist),
+  album_artist: text("album artist", (c) => c.meta.albumArtist),
+  album: text("album", (c) => c.meta.album),
+  title: text("title", (c) => c.meta.title),
+  genre: text("genre", (c) => c.meta.genre),
+  track: num2("track number", true, (c) => c.meta.track),
+  disc: num2("disc number", true, (c) => c.meta.disc),
+  year: num2("year", false, (c) => c.meta.year),
+  ext: text("extension", (c) => c.entry.ext || void 0),
+  parent: text("parent folder name", (c) => parentFolder(c.entry.dir)),
+  size: text("size", (c) => formatSize(c.entry.size)),
+  size_bytes: num2("size in bytes", false, (c) => c.entry.size),
+  crc32: text("CRC32", (c) => c.meta.crc32),
+  md5: text("MD5", (c) => c.meta.md5),
+  aperture: text("aperture", (c) => c.meta.aperture === void 0 ? void 0 : `f${trimNumber(c.meta.aperture, 1)}`),
+  shutter: text("shutter speed", (c) => c.meta.exposureSeconds === void 0 || c.meta.exposureSeconds <= 0 ? void 0 : formatExposure(c.meta.exposureSeconds)),
+  fps: text("frame rate", (c) => c.meta.frameRate === void 0 ? void 0 : trimNumber(c.meta.frameRate)),
+  bitrate: num2("bitrate in kbps", false, (c) => c.meta.bitrateKbps),
+  composer: text("composer", (c) => c.meta.composer)
+};
+function isTokenName(s) {
+  return Object.hasOwn(TOKENS, s);
+}
+
+// src/core/template/parse.ts
+var fail = (error2, index) => ({ ok: false, error: error2, index });
+function parseToken(body, index) {
+  const bar = body.indexOf("|");
+  const head = bar === -1 ? body : body.slice(0, bar);
+  const fallback = bar === -1 ? null : body.slice(bar + 1);
+  const colon = head.indexOf(":");
+  const name = colon === -1 ? head : head.slice(0, colon);
+  const format = colon === -1 ? null : head.slice(colon + 1);
+  if (name === "") return fail('Empty token "{}"', index);
+  if (!isTokenName(name)) return fail(`Unknown token "{${name}}"`, index);
+  const def = TOKENS[name];
+  if (format !== null) {
+    if (def.kind === "date") {
+      if (format === "") return fail(`Missing date format after "{${name}:"`, index);
+    } else if (def.kind === "number" && def.digitsFormat) {
+      const digits = Number(format);
+      if (!/^\d{1,2}$/.test(format) || digits < 1 || digits > 10) {
+        return fail(`"{${name}:${format}}" needs a number of digits from 1 to 10`, index);
+      }
+    } else {
+      return fail(`"{${name}}" doesn't take a format`, index);
+    }
+  }
+  return { ok: true, node: { type: "token", name, format, fallback } };
+}
+function scanPattern(pattern) {
+  if (pattern.trim() === "") return fail("The pattern is empty", 0);
+  const nodes = [];
+  const spans = [];
+  let text2 = "";
+  const flush = () => {
+    if (text2 !== "") {
+      nodes.push({ type: "text", value: text2 });
+      text2 = "";
+    }
+  };
+  let i = 0;
+  while (i < pattern.length) {
+    const ch = pattern.charAt(i);
+    const next = pattern.charAt(i + 1);
+    if (ch === "{" && next === "{") {
+      text2 += "{";
+      i += 2;
+      continue;
+    }
+    if (ch === "}" && next === "}") {
+      text2 += "}";
+      i += 2;
+      continue;
+    }
+    if (ch === "}") {
+      return fail(`Unexpected "}" at position ${i + 1}. Use "}}" for a literal brace.`, i);
+    }
+    if (ch === "/" || ch === "\\") {
+      flush();
+      nodes.push({ type: "separator" });
+      spans.push({ kind: "separator", start: i, end: i + 1 });
+      i += 1;
+      continue;
+    }
+    if (ch === "{") {
+      const close = pattern.indexOf("}", i + 1);
+      if (close === -1) return fail(`Unclosed "{" at position ${i + 1}`, i);
+      const parsed2 = parseToken(pattern.slice(i + 1, close), i);
+      if (!parsed2.ok) return parsed2;
+      flush();
+      const { name, format, fallback } = parsed2.node;
+      nodes.push(parsed2.node);
+      spans.push({ kind: "token", start: i, end: close + 1, name, format, fallback });
+      i = close + 1;
+      continue;
+    }
+    text2 += ch;
+    i += 1;
+  }
+  flush();
+  return { ok: true, nodes, spans };
+}
+function parsePattern(pattern) {
+  const r = scanPattern(pattern);
+  return r.ok ? { ok: true, nodes: r.nodes } : r;
+}
+
+// src/core/dateFormat.ts
+var DEFAULT_DATE_FORMAT = "YYYY-MM-DD";
+var MONTHS = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"];
+var DAYS = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"];
+var CODES = ["YYYY", "MMM", "SSS", "ddd", "YY", "MM", "DD", "HH", "hh", "mm", "ss", "A"];
+var pad2 = (n2, width = 2) => String(n2).padStart(width, "0");
+function dayOfWeek(wc) {
+  return new Date(Date.UTC(wc.year, wc.month - 1, wc.day)).getUTCDay();
+}
+function renderCode(code, wc) {
+  switch (code) {
+    case "YYYY":
+      return pad2(wc.year, 4);
+    case "YY":
+      return pad2(wc.year % 100);
+    case "MMM":
+      return MONTHS[wc.month - 1] ?? "";
+    case "MM":
+      return pad2(wc.month);
+    case "DD":
+      return pad2(wc.day);
+    case "ddd":
+      return DAYS[dayOfWeek(wc)] ?? "";
+    case "HH":
+      return pad2(wc.hour);
+    case "hh":
+      return pad2(wc.hour % 12 || 12);
+    case "A":
+      return wc.hour < 12 ? "AM" : "PM";
+    case "mm":
+      return pad2(wc.minute);
+    case "ss":
+      return pad2(wc.second);
+    case "SSS":
+      return pad2(wc.millisecond ?? 0, 3);
+  }
+}
+function formatWallClock(wc, format) {
+  let out = "";
+  let i = 0;
+  while (i < format.length) {
+    const code = CODES.find((c) => format.startsWith(c, i));
+    if (code) {
+      out += renderCode(code, wc);
+      i += code.length;
+    } else {
+      out += format.charAt(i);
+      i += 1;
+    }
+  }
+  return out;
+}
+
+// src/core/template/render.ts
+function renderPattern(nodes, ctx) {
+  let current = [];
+  const segments = [current];
+  const flags = [];
+  let firstDate = null;
+  const addFlag = (flag) => {
+    if (!flags.some((f) => f.code === flag.code && f.message === flag.message)) flags.push(flag);
+  };
+  for (const node of nodes) {
+    if (node.type === "text") {
+      current.push({ text: node.value, token: false });
+      continue;
+    }
+    if (node.type === "separator") {
+      current = [];
+      segments.push(current);
+      continue;
+    }
+    const def = TOKENS[node.name];
+    if (def.kind === "date") {
+      const r = resolveDate(ctx.meta, def.date);
+      if (r.fellBack) {
+        addFlag({ level: "warning", code: "fallback-date", message: fallbackMessage(def.date, r.source) });
+      }
+      firstDate ??= { value: r.value, source: r.source };
+      current.push({ text: formatWallClock(r.value, node.format ?? DEFAULT_DATE_FORMAT), token: true });
+      continue;
+    }
+    let value;
+    if (def.kind === "number") {
+      const n2 = def.get(ctx);
+      if (n2 !== void 0 && Number.isFinite(n2)) {
+        const digits = node.format !== null ? Number(node.format) : def.defaultDigits(ctx);
+        value = String(Math.trunc(n2)).padStart(digits, "0");
+      }
+    } else {
+      const s = def.get(ctx);
+      value = s === void 0 || s.trim() === "" ? void 0 : s;
+    }
+    if (value === void 0) {
+      if (node.fallback !== null) {
+        value = node.fallback;
+      } else {
+        addFlag({ level: "warning", code: "missing-value", message: `No ${def.label} for this file` });
+        value = "";
+      }
+    }
+    current.push({ text: value, token: true });
+  }
+  return { segments, flags, firstDate };
+}
+
+// src/core/planner.ts
+var MAX_SEGMENT_BYTES = 255;
+var WINDOWS_MAX_PATH = 260;
+var withExt = (stem, ext) => ext ? `${stem}.${ext}` : stem;
+var fileNameOf = (e) => withExt(e.stem, e.ext);
+var error = (code, message2) => ({ level: "error", code, message: message2 });
+var warning = (code, message2) => ({ level: "warning", code, message: message2 });
+var planCounter = 0;
+var newPlanId = () => `plan-${Date.now().toString(36)}-${planCounter += 1}`;
+function buildPlan(input) {
+  const { settings, fs, platform } = input;
+  const p = input.path ?? nodePath;
+  const timeZone = input.timeZone ?? systemTimeZone();
+  const id = input.planId ?? newPlanId();
+  const metaCache = /* @__PURE__ */ new Map();
+  const getMeta = (e) => {
+    let meta = metaCache.get(e);
+    if (!meta) {
+      meta = effectiveMetadata(input.metadata.get(e.path) ?? fsMetadata(e, timeZone), settings.dates);
+      metaCache.set(e, meta);
+    }
+    return meta;
+  };
+  const excluded = input.excluded ?? /* @__PURE__ */ new Set();
+  const groups = buildGroups(input.entries, getMeta, settings.sequence.keepGroupsTogether);
+  const sorted = sortGroups(groups, getMeta, settings.sequence.sortBy, settings.sequence.direction, input.manualOrder ?? []);
+  const planned = /* @__PURE__ */ new Map();
+  for (const g of sorted) {
+    const members = g.members.filter((m) => !excluded.has(m.path));
+    if (members.length === g.members.length) planned.set(g, g);
+    else if (members.length > 0) {
+      const primary = members.includes(g.primary) ? g.primary : choosePrimary(members, getMeta);
+      planned.set(g, { id: members.length === 1 ? primary.path : g.id, members, primary });
+    }
+  }
+  const sortKind = sortKeyToDateKind(settings.sequence.sortBy);
+  const dateOf = (g) => resolveDate(getMeta(g.primary), sortKind ?? "date_taken").value;
+  const seqs = assignSequence([...planned.values()], settings.sequence, dateOf);
+  const originalRules = rulesFor(settings.findReplace, "original");
+  const resultRules = rulesFor(settings.findReplace, "result");
+  const cleanupOpts = settings.cleanup;
+  const excludedItem = (entry) => ({
+    source: entry,
+    target: entry.path,
+    kind: "excluded",
+    flags: [],
+    seq: 0,
+    groupId: null,
+    dateUsed: null,
+    stem: entry.stem,
+    ext: entry.ext,
+    setDates: {}
+  });
+  const allErrors = (flag) => sorted.flatMap((g) => {
+    const pg = planned.get(g);
+    return g.members.map(
+      (entry) => !pg || excluded.has(entry.path) ? excludedItem(entry) : {
+        source: entry,
+        target: entry.path,
+        kind: "error",
+        flags: [flag],
+        seq: seqs.get(pg.id) ?? 0,
+        groupId: pg.members.length > 1 ? pg.id : null,
+        dateUsed: null,
+        stem: entry.stem,
+        ext: entry.ext,
+        setDates: {}
+      }
+    );
+  });
+  const errorCount = (items2) => items2.filter((i) => i.kind === "error").length;
+  const destinationRoot = settings.move.destinationRoot;
+  if (destinationRoot !== null && !p.isAbsolute(destinationRoot)) {
+    const items2 = allErrors(error("destination-unwritable", "The destination folder must be a full path"));
+    return { id, items: items2, patternError: null, errorCount: errorCount(items2), settings };
+  }
+  const resolvedRoot = destinationRoot !== null ? p.resolve(destinationRoot) : null;
+  const parsed2 = parsePattern(settings.pattern);
+  const rulesError = validateRules(settings.findReplace);
+  if (!parsed2.ok || rulesError !== null) {
+    const message2 = !parsed2.ok ? parsed2.error : rulesError ?? "";
+    const items2 = allErrors(error("pattern-error", message2));
+    return { id, items: items2, patternError: message2, errorCount: errorCount(items2), settings };
+  }
+  const drafts = sorted.flatMap((g) => {
+    const pg = planned.get(g);
+    const included = pg ? draftGroup(pg, parsed2.nodes, seqs.get(pg.id) ?? 0) : [];
+    return g.members.map((entry) => included.find((d) => d.entry === entry) ?? excludedDraft(entry, g));
+  });
+  const items = resolveConflicts(drafts);
+  return { id, items, patternError: null, errorCount: errorCount(items), settings };
+  function excludedDraft(entry, group) {
+    return {
+      entry,
+      group,
+      seq: 0,
+      targetDir: entry.dir,
+      stem: entry.stem,
+      ext: entry.ext,
+      flags: [],
+      error: false,
+      excluded: true,
+      dateUsed: null,
+      setDates: {}
+    };
+  }
+  function draftGroup(group, nodes, seq) {
+    const meta = getMeta(group.primary);
+    const name = applyFindReplace(group.primary.stem, originalRules);
+    const rendered = renderPattern(nodes, {
+      entry: group.primary,
+      meta,
+      name,
+      seq,
+      defaultDigits: settings.sequence.digits
+    });
+    const cleaned = rendered.segments.map((s) => cleanSegment(s, cleanupOpts));
+    const folders = cleaned.slice(0, -1);
+    let stem = cleaned[cleaned.length - 1] ?? "";
+    const override = group.members.map((m) => input.overrides?.get(m.path)).find((o) => o !== void 0 && o.trim() !== "");
+    const groupFlags = override === void 0 ? [...rendered.flags] : [];
+    if (override !== void 0) {
+      stem = cleanSegment([{ text: override.trim(), token: false }], cleanupOpts);
+      groupFlags.push({ level: "info", code: "edited", message: "Name typed by hand" });
+    } else if (resultRules.length > 0) {
+      stem = cleanSegment([{ text: applyFindReplace(stem, resultRules), token: false }], cleanupOpts);
+    }
+    const baseDir = resolvedRoot ?? group.primary.dir;
+    const targetDir = folders.length > 0 ? p.join(baseDir, ...folders) : baseDir;
+    if (stem === "") groupFlags.push(error("empty-segment", "The new name is empty"));
+    else if (folders.includes("")) groupFlags.push(error("empty-segment", "A folder name in the pattern is empty"));
+    for (const folder of folders) {
+      if (utf8Bytes(folder) > MAX_SEGMENT_BYTES) {
+        groupFlags.push(error("segment-too-long", `Folder name "${folder.slice(0, 24)}\u2026" is longer than 255 bytes`));
+      }
+    }
+    let dateUsed = rendered.firstDate;
+    if (!dateUsed && sortKind) {
+      const r = resolveDate(meta, sortKind);
+      dateUsed = { value: r.value, source: r.source };
+    }
+    const setDates = {};
+    const setCreated = settings.dates.setCreated && platform !== "linux";
+    const wantsDates = settings.dates.setModified || setCreated;
+    if (wantsDates && meta.dateTaken) {
+      if (settings.dates.setModified) setDates.modified = meta.dateTaken;
+      if (setCreated) setDates.created = meta.dateTaken;
+    } else if (wantsDates && !group.primary.isDir) {
+      groupFlags.push(warning("no-date-taken", "No date taken in this file; its dates are left unchanged"));
+    }
+    return group.members.map((entry) => {
+      const flags = [...groupFlags];
+      const memberMeta = getMeta(entry);
+      if (memberMeta.readError) {
+        flags.push(warning("metadata-unreadable", `Couldn't read metadata: ${memberMeta.readError}`));
+      }
+      if (group.members.length > 1) {
+        const others = group.members.filter((m) => m !== entry).map(fileNameOf).join(", ");
+        flags.push({ level: "info", code: "paired", message: `Paired with ${others}` });
+      }
+      const ext = entry.isDir ? "" : applyExtensionRules(entry.ext, settings.cleanup.extensionRules, settings.cleanup.lowercaseExtension);
+      if (entry.isDir) {
+        const self = nameKey(entry.path);
+        const into = nameKey(targetDir);
+        if (into === self || into.startsWith(`${self}/`) || into.startsWith(`${self}\\`)) {
+          flags.push(error("destination-unwritable", "A folder can't be moved into itself"));
+        }
+      }
+      if (stem !== "" && utf8Bytes(withExt(stem, ext)) > MAX_SEGMENT_BYTES) {
+        flags.push(error("segment-too-long", "The new name is longer than 255 bytes"));
+      }
+      const staysPut = targetDir === entry.dir && withExt(stem, ext) === fileNameOf(entry);
+      if (!staysPut && !fs.isWritableDir(fs.nearestExisting(targetDir))) {
+        flags.push(error("destination-unwritable", `Can't write to ${fs.nearestExisting(targetDir)}`));
+      }
+      return {
+        entry,
+        group,
+        seq,
+        targetDir,
+        stem,
+        ext,
+        flags,
+        error: flags.some((f) => f.level === "error"),
+        excluded: false,
+        dateUsed,
+        setDates: { ...setDates }
+      };
+    });
+  }
+  function resolveConflicts(all) {
+    const vacated = /* @__PURE__ */ new Map();
+    for (const d of all) {
+      if (d.error || d.excluded) continue;
+      const key = nameKey(d.entry.dir);
+      const set = vacated.get(key) ?? /* @__PURE__ */ new Set();
+      set.add(nameKey(fileNameOf(d.entry)));
+      vacated.set(key, set);
+    }
+    const occupiedCache = /* @__PURE__ */ new Map();
+    const occupied = (dir) => {
+      const key = nameKey(dir);
+      let set = occupiedCache.get(key);
+      if (!set) {
+        set = new Set((fs.listDir(dir) ?? []).map(nameKey));
+        for (const k of vacated.get(key) ?? []) set.delete(k);
+        occupiedCache.set(key, set);
+      }
+      return set;
+    };
+    const claimed = /* @__PURE__ */ new Map();
+    const claimedIn = (dir) => {
+      const key = nameKey(dir);
+      const set = claimed.get(key) ?? /* @__PURE__ */ new Set();
+      claimed.set(key, set);
+      return set;
+    };
+    const nextSuffix = /* @__PURE__ */ new Map();
+    const units = [];
+    let open;
+    for (const d of all) {
+      if (d.excluded) units.push([d]);
+      else if (!d.error && open && open[0]?.group === d.group) open.push(d);
+      else {
+        const unit = [d];
+        units.push(unit);
+        open = d.error ? void 0 : unit;
+      }
+    }
+    const splitUnits = units.flatMap((u) => {
+      const keys = u.map((d) => nameKey(withExt(d.stem, d.ext)));
+      return new Set(keys).size === keys.length ? [u] : u.map((d) => [d]);
+    });
+    const items2 = [];
+    for (const unit of splitUnits) {
+      const first = unit[0];
+      if (!first) continue;
+      if (first.excluded) {
+        items2.push(excludedItem(first.entry));
+        continue;
+      }
+      if (first.error) {
+        items2.push(toItem(first, first.entry.path, "error", first.flags, first.stem));
+        continue;
+      }
+      const baseKey = JSON.stringify(unit.map((d) => [nameKey(d.targetDir), nameKey(d.stem), nameKey(d.ext)]));
+      let n2 = nextSuffix.get(baseKey) ?? 1;
+      let names = [];
+      for (; ; n2 += 1) {
+        const suffix2 = n2 === 1 ? "" : `_${n2}`;
+        names = unit.map((d) => withExt(d.stem + suffix2, d.ext));
+        const free = unit.every((d, i) => {
+          const k = nameKey(names[i] ?? "");
+          return !occupied(d.targetDir).has(k) && !claimedIn(d.targetDir).has(k);
+        });
+        if (free) break;
+      }
+      nextSuffix.set(baseKey, n2 + 1);
+      const suffix = n2 === 1 ? "" : `_${n2}`;
+      unit.forEach((d, i) => {
+        const stem = `${d.stem}${suffix}`;
+        const name = names[i] ?? "";
+        claimedIn(d.targetDir).add(nameKey(name));
+        const target = p.join(d.targetDir, name);
+        const flags = [...d.flags];
+        if (n2 > 1) flags.push(warning("suffix-added", `Added _${n2} because the name was already taken`));
+        if (platform === "win32" && target.length >= WINDOWS_MAX_PATH) {
+          flags.push(error("path-too-long", "The full path is longer than Windows allows (260 characters)"));
+          items2.push(toItem(d, d.entry.path, "error", flags, stem));
+          return;
+        }
+        if (target === d.entry.path) {
+          items2.push(toItem(d, target, "unchanged", flags, stem));
+        } else if (nameKey(d.targetDir) === nameKey(d.entry.dir)) {
+          items2.push(toItem(d, target, "rename", flags, stem));
+        } else if (fs.deviceOf(fs.nearestExisting(d.targetDir)) !== d.entry.dev) {
+          if (d.entry.isDir) {
+            flags.push(error("folder-cross-drive", "Folders can't be moved to another drive"));
+            items2.push(toItem(d, d.entry.path, "error", flags, stem));
+            return;
+          }
+          flags.push(warning("cross-drive", "Moves to another drive: copied, checked, then the original is deleted. The copy gets a new created date."));
+          items2.push(toItem(d, target, "cross-drive-move", flags, stem));
+        } else {
+          items2.push(toItem(d, target, "move", flags, stem));
+        }
+      });
+    }
+    if (excluded.size === 0) return items2;
+    const order = new Map(all.map((d, i) => [d.entry.path, i]));
+    return items2.sort((x, y) => (order.get(x.source.path) ?? 0) - (order.get(y.source.path) ?? 0));
+  }
+  function toItem(d, target, kind, flags, stem) {
+    return {
+      source: d.entry,
+      target,
+      kind,
+      flags,
+      seq: d.seq,
+      groupId: d.group.members.length > 1 ? d.group.id : null,
+      dateUsed: d.dateUsed,
+      stem,
+      ext: d.ext,
+      setDates: kind === "error" ? {} : d.setDates
+    };
+  }
+}
+
+// src/core/fsview.ts
+import { accessSync, constants, readdirSync, statSync } from "node:fs";
+import path2 from "node:path";
+function cached(fn) {
+  const cache = /* @__PURE__ */ new Map();
+  return (key) => {
+    if (!cache.has(key)) cache.set(key, fn(key));
+    return cache.get(key);
+  };
+}
+function createFsView() {
+  return {
+    listDir: cached((dir) => {
+      try {
+        return readdirSync(dir);
+      } catch {
+        return null;
+      }
+    }),
+    nearestExisting: cached((p) => {
+      let current = path2.resolve(p);
+      for (; ; ) {
+        try {
+          statSync(current);
+          return current;
+        } catch {
+          const parent = path2.dirname(current);
+          if (parent === current) return current;
+          current = parent;
+        }
+      }
+    }),
+    deviceOf: cached((existingPath) => statSync(existingPath).dev),
+    isWritableDir: cached((dir) => {
+      try {
+        accessSync(dir, constants.W_OK);
+        return true;
+      } catch {
+        return false;
+      }
+    })
+  };
+}
+
+// src/core/executor/execute.ts
+import { randomUUID } from "node:crypto";
+import { stat as stat3, utimes as utimes2 } from "node:fs/promises";
+
+// src/core/executor/birthtime.ts
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+
+// src/core/executor/moves.ts
+import { constants as constants2 } from "node:fs";
+import { copyFile, lstat as lstat2, mkdir, rename, rmdir, stat as stat2, unlink, utimes } from "node:fs/promises";
+import path3 from "node:path";
+var CancelledError = class extends Error {
+  constructor() {
+    super("Cancelled");
+    this.name = "CancelledError";
+  }
+};
+async function exists(p) {
+  try {
+    await lstat2(p);
+    return true;
+  } catch (e) {
+    const code = e.code;
+    if (code === "ENOENT" || code === "ENOTDIR") return false;
+    throw e;
+  }
+}
+var tempName = (batchId, index, suffix = "tmp") => `.renami-${batchId}-${index}.${suffix}`;
+function checkCancelled(ctx) {
+  if (ctx.signal?.aborted) throw new CancelledError();
+}
+async function ensureDir(dir, ctx, ensured) {
+  if (ensured.has(dir)) return;
+  const missing = [];
+  let current = dir;
+  while (!await exists(current)) {
+    missing.push(current);
+    const parent = path3.dirname(current);
+    if (parent === current) break;
+    current = parent;
+  }
+  for (const d of missing.reverse()) {
+    await mkdir(d);
+    ctx.journal.push({ type: "mkdir", dir: d });
+    ctx.createdDirs.push(d);
+  }
+  ensured.add(dir);
+}
+async function copyAcross(source, target, staging, ctx) {
+  const st = await stat2(source);
+  await copyFile(source, staging, constants2.COPYFILE_EXCL);
+  ctx.journal.push({ type: "copy", to: staging });
+  await utimes(staging, st.atime, st.mtime);
+  if ((await stat2(staging)).size !== st.size) throw new Error(`Copy of ${source} is incomplete`);
+  if (await exists(target)) throw new Error(`Target already exists: ${target}`);
+  await rename(staging, target);
+  ctx.journal.push({ type: "rename", from: staging, to: target });
+  await unlink(source);
+  ctx.journal.push({ type: "delete-after-copy", source, copy: target });
+}
+async function runMoves(ops, ctx) {
+  const temps = [];
+  const ensured = /* @__PURE__ */ new Set();
+  for (const [i, op] of ops.entries()) {
+    checkCancelled(ctx);
+    const tmp = path3.join(path3.dirname(op.from), tempName(ctx.batchId, i));
+    if (await exists(tmp)) throw new Error(`Temporary name already exists: ${tmp}`);
+    await rename(op.from, tmp);
+    ctx.journal.push({ type: "rename", from: op.from, to: tmp });
+    temps.push(tmp);
+    ctx.onStep?.();
+  }
+  for (const [i, op] of ops.entries()) {
+    checkCancelled(ctx);
+    const tmp = temps[i];
+    if (tmp === void 0) throw new Error("internal: missing temp name");
+    await ensureDir(path3.dirname(op.to), ctx, ensured);
+    if (await exists(op.to)) throw new Error(`Target already exists: ${op.to}`);
+    if (op.crossDrive) {
+      await copyAcross(tmp, op.to, path3.join(path3.dirname(op.to), tempName(ctx.batchId, i, "copy")), ctx);
+    } else {
+      await rename(tmp, op.to);
+      ctx.journal.push({ type: "rename", from: tmp, to: op.to });
+    }
+    ctx.onStep?.();
+  }
+}
+function originOf(index, p, journal) {
+  let current = p;
+  for (let i = index - 1; i >= 0; i -= 1) {
+    const step = journal[i];
+    if (step?.type === "rename" && step.to === current) current = step.from;
+  }
+  return current;
+}
+async function rollback(journal, restoreTimes) {
+  const stranded = [];
+  const datesNotRestored = [];
+  const dead = /* @__PURE__ */ new Set();
+  for (let i = journal.length - 1; i >= 0; i -= 1) {
+    const step = journal[i];
+    if (!step) continue;
+    try {
+      switch (step.type) {
+        case "rename":
+          if (dead.has(step.to)) {
+            dead.add(step.from);
+            break;
+          }
+          if (await exists(step.from) || !await exists(step.to)) throw new Error("cannot restore");
+          await rename(step.to, step.from);
+          break;
+        case "mkdir":
+          await rmdir(step.dir).catch(() => void 0);
+          break;
+        case "copy":
+          if (!dead.has(step.to)) {
+            await unlink(step.to).catch(() => void 0);
+          }
+          break;
+        case "delete-after-copy": {
+          if (dead.has(step.copy)) {
+            dead.add(step.source);
+            break;
+          }
+          await copyFile(step.copy, step.source, constants2.COPYFILE_EXCL);
+          const st = await stat2(step.copy);
+          await utimes(step.source, st.atime, st.mtime);
+          datesNotRestored.push(originOf(i, step.source, journal));
+          break;
+        }
+        case "times":
+          await restoreTimes(step.path, step.before);
+          break;
+      }
+    } catch {
+      if (step.type === "rename") {
+        stranded.push({ original: originOf(i, step.from, journal), current: step.to });
+        dead.add(step.from);
+      } else if (step.type === "delete-after-copy") {
+        stranded.push({ original: originOf(i, step.source, journal), current: step.copy });
+        dead.add(step.copy);
+        dead.add(step.source);
+      } else if (step.type === "times") {
+        datesNotRestored.push(step.path);
+      }
+    }
+  }
+  const result = {
+    complete: stranded.length === 0 && datesNotRestored.length === 0,
+    stranded
+  };
+  if (datesNotRestored.length > 0) result.datesNotRestored = datesNotRestored;
+  return result;
+}
+
+// src/core/executor/birthtime.ts
+var run = promisify(execFile);
+var MAC_SCRIPT = `
+ObjC.import('Foundation');
+function run(argv) {
+  const fm = $.NSFileManager.defaultManager;
+  for (let i = 0; i < argv.length; i += 2) {
+    const date = $.NSDate.dateWithTimeIntervalSince1970(Number(argv[i + 1]));
+    const attrs = $.NSDictionary.dictionaryWithObjectForKey(date, $.NSFileCreationDate);
+    if (!fm.setAttributesOfItemAtPathError(attrs, argv[i], null)) {
+      throw new Error('Could not set the created date of ' + argv[i]);
+    }
+  }
+  return 'ok';
+}`;
+function chunks(items, size) {
+  const out = [];
+  for (let i = 0; i < items.length; i += size) out.push(items.slice(i, i + size));
+  return out;
+}
+async function runTool(cmd, args) {
+  try {
+    await run(cmd, args);
+  } catch (e) {
+    const err = e;
+    throw new Error((err.stderr ?? "").trim() || "The created-date tool failed");
+  }
+}
+var WINDOWS_JSON_BUDGET = 7e3;
+function windowsPayload(chunk) {
+  return JSON.stringify(chunk.map((it) => ({ p: it.path, t: Math.round(it.timeMs) })));
+}
+function windowsChunks(items) {
+  const out = [];
+  let current = [];
+  for (const item of items) {
+    const candidate = [...current, item];
+    if (current.length > 0 && Buffer.byteLength(windowsPayload(candidate), "utf8") > WINDOWS_JSON_BUDGET) {
+      out.push(current);
+      current = [item];
+    } else {
+      current = candidate;
+    }
+  }
+  if (current.length > 0) out.push(current);
+  return out;
+}
+function windowsScript(chunk) {
+  const payload = Buffer.from(windowsPayload(chunk), "utf8").toString("base64");
+  return `$ErrorActionPreference = 'Stop'; $items = [Text.Encoding]::UTF8.GetString([Convert]::FromBase64String('${payload}')) | ConvertFrom-Json; foreach ($i in $items) { [System.IO.File]::SetCreationTimeUtc($i.p, [DateTimeOffset]::FromUnixTimeMilliseconds([int64]$i.t).UtcDateTime) }`;
+}
+function createBirthtimeSetter(platform) {
+  if (platform === "darwin") {
+    return {
+      supported: true,
+      async set(items, signal) {
+        for (const chunk of chunks(items, 200)) {
+          if (signal?.aborted) throw new CancelledError();
+          const args = chunk.flatMap((it) => [it.path, String(it.timeMs / 1e3)]);
+          await runTool("osascript", ["-l", "JavaScript", "-e", MAC_SCRIPT, ...args]);
+        }
+      }
+    };
+  }
+  if (platform === "win32") {
+    return {
+      supported: true,
+      async set(items, signal) {
+        for (const chunk of windowsChunks(items)) {
+          if (signal?.aborted) throw new CancelledError();
+          const encoded = Buffer.from(windowsScript(chunk), "utf16le").toString("base64");
+          await runTool("powershell.exe", ["-NoProfile", "-NonInteractive", "-EncodedCommand", encoded]);
+        }
+      }
+    };
+  }
+  return {
+    supported: false,
+    async set() {
+      throw new Error("Setting created dates is not supported on Linux");
+    }
+  };
+}
+
+// src/core/executor/execute.ts
+function makeTimesRestorer(birthtime) {
+  return async (p, before) => {
+    const now = await timesOf(p);
+    if (Math.abs(now.mtimeMs - before.mtimeMs) >= 1) {
+      await utimes2(p, before.atimeMs / 1e3, before.mtimeMs / 1e3);
+    }
+    if (before.birthtimeMs !== null && birthtime.supported) {
+      const after = await timesOf(p);
+      if (after.birthtimeMs === null || Math.abs(after.birthtimeMs - before.birthtimeMs) >= 1) {
+        await birthtime.set([{ path: p, timeMs: before.birthtimeMs }]);
+      }
+    }
+  };
+}
+async function timesOf(p) {
+  const st = await stat3(p);
+  return { atimeMs: st.atimeMs, mtimeMs: st.mtimeMs, birthtimeMs: st.birthtimeMs > 0 ? st.birthtimeMs : null };
+}
+async function executePlan(plan, opts = {}) {
+  const noRollback = { complete: true, stranded: [] };
+  if (plan.errorCount > 0 || plan.patternError !== null) {
+    return { status: "failed", error: "The plan has errors. Fix or exclude those files first.", rollback: noRollback };
+  }
+  const birthtime = opts.birthtime ?? createBirthtimeSetter(process.platform);
+  const batchId = opts.batchId ?? randomUUID().slice(0, 8);
+  const moving = plan.items.filter((i) => isMoving(i.kind));
+  const dating = plan.items.filter((i) => hasPlannedDates(i.setDates));
+  const touched = /* @__PURE__ */ new Set([...moving, ...dating]);
+  const changed = [];
+  try {
+    for (const item of touched) {
+      try {
+        const st = await stat3(item.source.path);
+        if (st.size !== item.source.size || st.mtimeMs !== item.source.mtimeMs) changed.push(item.source.path);
+      } catch {
+        changed.push(item.source.path);
+      }
+    }
+    const leaving = new Set(moving.map((i) => nameKey(i.source.path)));
+    for (const item of moving) {
+      if (await exists(item.target) && !leaving.has(nameKey(item.target))) changed.push(item.target);
+    }
+  } catch (e) {
+    return { status: "failed", error: e instanceof Error ? e.message : String(e), rollback: noRollback };
+  }
+  if (changed.length > 0) return { status: "stale", changed };
+  const journal = [];
+  const createdDirs = [];
+  const total = moving.length * 2 + dating.length;
+  let done = 0;
+  const tick = () => {
+    done += 1;
+    opts.onProgress?.(done, total);
+  };
+  const ctx = { batchId, journal, createdDirs, onStep: tick };
+  if (opts.signal) ctx.signal = opts.signal;
+  const originalTimes = /* @__PURE__ */ new Map();
+  try {
+    await runMoves(
+      moving.map((i) => ({ from: i.source.path, to: i.target, crossDrive: i.kind === "cross-drive-move" })),
+      ctx
+    );
+    const created = [];
+    for (const item of dating) {
+      if (opts.signal?.aborted) throw new CancelledError();
+      const before = await timesOf(item.target);
+      journal.push({ type: "times", path: item.target, before });
+      originalTimes.set(item.target, before);
+      if (item.setDates.created) {
+        created.push({ path: item.target, timeMs: wallClockToLocalDate(item.setDates.created).getTime() });
+      }
+    }
+    if (created.length > 0) await birthtime.set(created, opts.signal);
+    for (const item of dating) {
+      if (opts.signal?.aborted) throw new CancelledError();
+      const before = originalTimes.get(item.target);
+      if (item.setDates.modified && before) {
+        await utimes2(item.target, before.atimeMs / 1e3, wallClockToLocalDate(item.setDates.modified));
+      }
+      tick();
+    }
+    const files = [];
+    for (const item of plan.items) {
+      if (!touched.has(item)) continue;
+      const st = await stat3(item.target);
+      files.push({
+        from: item.source.path,
+        to: item.target,
+        sizeAfter: st.size,
+        mtimeMsAfter: st.mtimeMs,
+        originalTimes: originalTimes.get(item.target) ?? null
+      });
+    }
+    return { status: "done", record: { id: batchId, files, createdDirs, finishedAt: Date.now() } };
+  } catch (e) {
+    const report = await rollback(journal, makeTimesRestorer(birthtime));
+    if (e instanceof CancelledError) return { status: "cancelled", error: null, rollback: report };
+    return { status: "failed", error: e instanceof Error ? e.message : String(e), rollback: report };
+  }
+}
+
+// src/core/hash.ts
+import { createHash } from "node:crypto";
+import { createReadStream } from "node:fs";
+import { crc32 } from "node:zlib";
+function crc32Update(crc, chunk) {
+  return crc32(chunk, crc);
+}
+var hex8 = (n2) => n2.toString(16).padStart(8, "0");
+async function hashFile(filePath, signal) {
+  if (signal?.aborted) throw new Error("Cancelled");
+  const md5 = createHash("md5");
+  let crc = 0;
+  const stream = createReadStream(filePath, { highWaterMark: 1024 * 1024 });
+  try {
+    for await (const chunk of stream) {
+      if (signal?.aborted) throw new Error("Cancelled");
+      const bytes = chunk;
+      md5.update(bytes);
+      crc = crc32Update(crc, bytes);
+    }
+  } finally {
+    stream.destroy();
+  }
+  return { crc32: hex8(crc), md5: md5.digest("hex") };
+}
+
+// src/core/history.ts
+import { randomUUID as randomUUID2 } from "node:crypto";
+import { rmdir as rmdir2, stat as stat4, utimes as utimes3 } from "node:fs/promises";
+import path4 from "node:path";
+async function crossesDrive(from, to) {
+  const source = await stat4(from);
+  let dir = path4.dirname(to);
+  while (!await exists(dir)) {
+    const parent = path4.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return (await stat4(dir)).dev !== source.dev;
+}
+var History = class {
+  stack = [];
+  running = false;
+  push(record) {
+    this.stack.push(record);
+  }
+  canUndo() {
+    return this.stack.length > 0;
+  }
+  peek() {
+    return this.stack[this.stack.length - 1];
+  }
+  get size() {
+    return this.stack.length;
+  }
+  async undo(opts = {}) {
+    if (this.running) {
+      return { status: "failed", restored: 0, skipped: [], error: "An undo is already running", rollback: null };
+    }
+    this.running = true;
+    try {
+      const record = this.peek();
+      if (!record) return { status: "nothing-to-undo", restored: 0, skipped: [], error: null, rollback: null };
+      const birthtime = opts.birthtime ?? createBirthtimeSetter(process.platform);
+      const restoreTimes = makeTimesRestorer(birthtime);
+      const skipped = [];
+      let restorable;
+      let ops;
+      try {
+        const unchanged = [];
+        for (const f of record.files) {
+          try {
+            const st = await stat4(f.to);
+            if (st.size !== f.sizeAfter || st.mtimeMs !== f.mtimeMsAfter) {
+              skipped.push({ path: f.to, reason: "Changed since the rename" });
+              continue;
+            }
+          } catch (e) {
+            const code = e.code;
+            const reason = code === "ENOENT" || code === "ENOTDIR" ? "No longer at its new location" : `Couldn't check it: ${e instanceof Error ? e.message : String(e)}`;
+            skipped.push({ path: f.to, reason });
+            continue;
+          }
+          unchanged.push(f);
+        }
+        restorable = unchanged;
+        for (; ; ) {
+          const leaving = new Set(restorable.filter((f) => f.from !== f.to).map((f) => nameKey(f.to)));
+          const kept = [];
+          for (const f of restorable) {
+            if (f.from !== f.to && await exists(f.from) && !leaving.has(nameKey(f.from))) {
+              skipped.push({ path: f.to, reason: "Its original name is taken by another file" });
+            } else {
+              kept.push(f);
+            }
+          }
+          if (kept.length === restorable.length) break;
+          restorable = kept;
+        }
+        ops = [];
+        for (const f of restorable) {
+          if (f.from !== f.to) ops.push({ from: f.to, to: f.from, crossDrive: await crossesDrive(f.to, f.from) });
+        }
+      } catch (e) {
+        return {
+          status: "failed",
+          restored: 0,
+          skipped,
+          error: e instanceof Error ? e.message : String(e),
+          rollback: { complete: true, stranded: [] }
+        };
+      }
+      const journal = [];
+      const ctx = { batchId: `undo-${record.id}-${randomUUID2().slice(0, 8)}`, journal, createdDirs: [] };
+      if (opts.signal) ctx.signal = opts.signal;
+      try {
+        if (opts.signal?.aborted) throw new CancelledError();
+        await runMoves(ops, ctx);
+        const created = [];
+        for (const f of restorable) {
+          if (!f.originalTimes) continue;
+          if (opts.signal?.aborted) throw new CancelledError();
+          const now = await timesOf(f.from);
+          journal.push({ type: "times", path: f.from, before: now });
+          if (Math.abs(now.mtimeMs - f.originalTimes.mtimeMs) >= 1) {
+            await utimes3(f.from, f.originalTimes.atimeMs / 1e3, f.originalTimes.mtimeMs / 1e3);
+          }
+          const wanted = f.originalTimes.birthtimeMs;
+          if (wanted !== null && birthtime.supported) {
+            const after = await timesOf(f.from);
+            if (after.birthtimeMs === null || Math.abs(after.birthtimeMs - wanted) >= 1) {
+              created.push({ path: f.from, timeMs: wanted });
+            }
+          }
+        }
+        if (created.length > 0) await birthtime.set(created, opts.signal);
+      } catch (e) {
+        const report = await rollback(journal, restoreTimes);
+        if (e instanceof CancelledError) {
+          return { status: "cancelled", restored: 0, skipped, error: null, rollback: report };
+        }
+        return { status: "failed", restored: 0, skipped, error: e instanceof Error ? e.message : String(e), rollback: report };
+      }
+      for (const dir of [...record.createdDirs].sort((a, b) => b.length - a.length)) {
+        await rmdir2(dir).catch(() => void 0);
+      }
+      const i = this.stack.lastIndexOf(record);
+      if (i !== -1) this.stack.splice(i, 1);
+      return { status: "done", restored: restorable.length, skipped, error: null, rollback: null };
+    } finally {
+      this.running = false;
+    }
+  }
+};
+
+// src/core/presets.ts
+var isObject = (v) => typeof v === "object" && v !== null;
+var bool = (v, fallback) => typeof v === "boolean" ? v : fallback;
+var oneOf = (v, options, fallback) => options.includes(v) ? v : fallback;
+var int = (v, fallback, min, max) => {
+  if (!Number.isInteger(v)) return fallback;
+  const n2 = v;
+  if (min !== void 0 && n2 < min) return fallback;
+  if (max !== void 0 && n2 > max) return fallback;
+  return n2;
+};
+var stringOrNull = (v, fallback) => typeof v === "string" || v === null ? v : fallback;
+var stringArray = (v, fallback) => {
+  if (Array.isArray(v) && v.every((e) => typeof e === "string")) return v;
+  return v === null ? null : fallback;
+};
+var DATE_ONLY2 = /^\d{4}-\d{2}-\d{2}$/;
+var dateOrNull = (v) => typeof v === "string" && DATE_ONLY2.test(v) ? v : null;
+var intOrNull = (v, min) => Number.isInteger(v) && v >= min ? v : null;
+function withDefaults(partial) {
+  const p = isObject(partial) ? partial : {};
+  const seq = isObject(p.sequence) ? p.sequence : {};
+  const cleanup = isObject(p.cleanup) ? p.cleanup : {};
+  const move = isObject(p.move) ? p.move : {};
+  const dates = isObject(p.dates) ? p.dates : {};
+  return {
+    pattern: typeof p.pattern === "string" ? p.pattern : DEFAULT_SETTINGS.pattern,
+    sequence: {
+      sortBy: oneOf(seq.sortBy, ["dateTaken", "created", "modified", "name", "manual"], DEFAULT_SETTINGS.sequence.sortBy),
+      direction: oneOf(seq.direction, ["asc", "desc"], DEFAULT_SETTINGS.sequence.direction),
+      start: int(seq.start, DEFAULT_SETTINGS.sequence.start, 0, 999999999),
+      step: int(seq.step, DEFAULT_SETTINGS.sequence.step, 1, 1e6),
+      digits: int(seq.digits, DEFAULT_SETTINGS.sequence.digits, 1, 10),
+      restartPerFolder: bool(seq.restartPerFolder, DEFAULT_SETTINGS.sequence.restartPerFolder),
+      restartEvery: oneOf(seq.restartEvery, ["never", "day", "month", "year"], DEFAULT_SETTINGS.sequence.restartEvery),
+      keepGroupsTogether: bool(seq.keepGroupsTogether, DEFAULT_SETTINGS.sequence.keepGroupsTogether)
+    },
+    findReplace: Array.isArray(p.findReplace) ? p.findReplace.filter(
+      (item) => isObject(item) && typeof item.find === "string" && typeof item.replace === "string" && typeof item.regex === "boolean" && typeof item.matchCase === "boolean"
+    ).map((item) => {
+      const rule = {
+        find: item.find,
+        replace: item.replace,
+        regex: item.regex,
+        matchCase: item.matchCase
+      };
+      if (item.scope === "original" || item.scope === "result") rule.scope = item.scope;
+      return rule;
+    }) : [],
+    cleanup: {
+      caseMode: oneOf(
+        cleanup.caseMode,
+        ["none", "lower", "upper", "title", "sentence", "snake", "kebab", "camel"],
+        DEFAULT_SETTINGS.cleanup.caseMode
+      ),
+      spacesToUnderscores: bool(cleanup.spacesToUnderscores, DEFAULT_SETTINGS.cleanup.spacesToUnderscores),
+      lowercaseExtension: bool(cleanup.lowercaseExtension, DEFAULT_SETTINGS.cleanup.lowercaseExtension),
+      stripDiacritics: bool(cleanup.stripDiacritics, DEFAULT_SETTINGS.cleanup.stripDiacritics),
+      asciiOnly: bool(cleanup.asciiOnly, DEFAULT_SETTINGS.cleanup.asciiOnly),
+      extensionRules: Array.isArray(cleanup.extensionRules) ? cleanup.extensionRules.filter((r) => isObject(r) && typeof r.from === "string" && typeof r.to === "string").map((r) => ({ from: normalizeExtension(r.from), to: normalizeExtension(r.to) })).filter((r) => r.from !== "") : []
+    },
+    move: {
+      destinationRoot: stringOrNull(move.destinationRoot, DEFAULT_SETTINGS.move.destinationRoot)
+    },
+    dates: {
+      setModified: bool(dates.setModified, DEFAULT_SETTINGS.dates.setModified),
+      setCreated: bool(dates.setCreated, DEFAULT_SETTINGS.dates.setCreated),
+      shiftMinutes: int(dates.shiftMinutes, DEFAULT_SETTINGS.dates.shiftMinutes, -1e6, 1e6),
+      useNameDate: bool(dates.useNameDate, DEFAULT_SETTINGS.dates.useNameDate)
+    },
+    filter: filterWithDefaults(p.filter)
+  };
+}
+function filterWithDefaults(v) {
+  const filter = isObject(v) ? v : {};
+  return {
+    includeSubfolders: bool(filter.includeSubfolders, DEFAULT_SETTINGS.filter.includeSubfolders),
+    extensions: stringArray(filter.extensions, DEFAULT_SETTINGS.filter.extensions),
+    mode: oneOf(filter.mode, ["files", "folders"], DEFAULT_SETTINGS.filter.mode),
+    name: {
+      text: isObject(filter.name) && typeof filter.name.text === "string" ? filter.name.text : "",
+      regex: isObject(filter.name) ? bool(filter.name.regex, false) : false
+    },
+    minBytes: intOrNull(filter.minBytes, 0),
+    maxBytes: intOrNull(filter.maxBytes, 0),
+    modifiedFrom: dateOrNull(filter.modifiedFrom),
+    modifiedTo: dateOrNull(filter.modifiedTo)
+  };
+}
+
+// src/core/pipeline.ts
+var EXIFTOOL_FAILURE_LIMIT = 5;
+var HASH_CONCURRENCY = 4;
+var READ_CONCURRENCY = 8;
+function patternUsesHash(pattern) {
+  const parsed2 = parsePattern(pattern);
+  return parsed2.ok && parsed2.nodes.some((n2) => n2.type === "token" && (n2.name === "crc32" || n2.name === "md5"));
+}
+async function readMetadata(entries, reader, opts = {}) {
+  const stop = new AbortController();
+  const signal = opts.signal ? AbortSignal.any([opts.signal, stop.signal]) : stop.signal;
+  let failuresInARow = 0;
+  let exiftoolFailed = false;
+  let probing = false;
+  let probe = null;
+  let threw = false;
+  let error2;
+  const onResult = (p, meta) => {
+    if (threw || opts.signal?.aborted) return;
+    failuresInARow = meta.readError === void 0 ? 0 : failuresInARow + 1;
+    if (failuresInARow >= EXIFTOOL_FAILURE_LIMIT && !exiftoolFailed && !probing) {
+      probing = true;
+      probe = reader.isWorking().then((working) => {
+        probing = false;
+        if (opts.signal?.aborted) return;
+        if (working) {
+          failuresInARow = 0;
+        } else {
+          exiftoolFailed = true;
+          stop.abort();
+        }
+      });
+    }
+    try {
+      opts.onResult?.(p, meta, { exiftoolFailed });
+    } catch (e) {
+      threw = true;
+      error2 = e;
+      throw e;
+    }
+  };
+  try {
+    await reader.readAll(entries, void 0, READ_CONCURRENCY, { signal, onResult });
+  } catch (e) {
+    if (!threw) {
+      threw = true;
+      error2 = e;
+    }
+    stop.abort();
+  }
+  if (probe) await probe;
+  return threw ? { exiftoolFailed, error: error2 } : { exiftoolFailed };
+}
+var sizeKey = (e) => `${e.size}:${e.mtimeMs}`;
+var HashCache = class {
+  constructor(timeZone) {
+    this.timeZone = timeZone;
+  }
+  timeZone;
+  hashes = /* @__PURE__ */ new Map();
+  get size() {
+    return this.hashes.size;
+  }
+  /** Hashes the files that have no current hash, HASH_CONCURRENCY at a time. Skips folders. */
+  async hashMissing(entries, signal) {
+    const todo = entries.filter((e) => !e.isDir && this.hashes.get(e.path)?.key !== sizeKey(e));
+    let next = 0;
+    const worker = async () => {
+      while (next < todo.length) {
+        if (signal?.aborted) return;
+        const entry = todo[next];
+        next += 1;
+        if (!entry) continue;
+        try {
+          const h = await hashFile(entry.path, signal);
+          this.hashes.set(entry.path, { key: sizeKey(entry), ...h });
+        } catch {
+        }
+      }
+    };
+    await Promise.all(Array.from({ length: Math.min(HASH_CONCURRENCY, todo.length) }, worker));
+  }
+  /** The file's metadata with its current hashes, or undefined when it has none. */
+  withHash(entry, metadata) {
+    const h = this.hashes.get(entry.path);
+    if (!h || h.key !== sizeKey(entry)) return void 0;
+    return { ...metadata.get(entry.path) ?? fsMetadata(entry, this.timeZone), crc32: h.crc32, md5: h.md5 };
+  }
+  /** The metadata map with current hashes merged in; the map itself when there are none. */
+  mergeInto(metadata, entries) {
+    if (this.hashes.size === 0) return metadata;
+    const out = new Map(metadata);
+    for (const e of entries) {
+      const meta = this.withHash(e, metadata);
+      if (meta) out.set(e.path, meta);
+    }
+    return out;
+  }
+};
+
+// src/cli/args.ts
+import { readFile } from "node:fs/promises";
+import path5 from "node:path";
+import { parseArgs } from "node:util";
+var UsageError = class extends Error {
+  constructor(message2) {
+    super(message2);
+    this.name = "UsageError";
+  }
+};
+var SORTS = ["dateTaken", "created", "modified", "name"];
+var RESTARTS = ["never", "day", "month", "year"];
+var CASES = ["none", "lower", "upper", "title", "sentence", "snake", "kebab", "camel"];
+var RENAME_OPTIONS = {
+  settings: { type: "string" },
+  pattern: { type: "string", short: "p" },
+  sort: { type: "string" },
+  desc: { type: "boolean" },
+  start: { type: "string" },
+  step: { type: "string" },
+  digits: { type: "string" },
+  restart: { type: "string" },
+  "restart-per-folder": { type: "boolean" },
+  replace: { type: "string", multiple: true },
+  regex: { type: "boolean" },
+  "match-case": { type: "boolean" },
+  case: { type: "string" },
+  "spaces-to-underscores": { type: "boolean" },
+  ascii: { type: "boolean" },
+  "strip-accents": { type: "boolean" },
+  ext: { type: "string", multiple: true },
+  dest: { type: "string" },
+  shift: { type: "string" },
+  "use-name-date": { type: "boolean" },
+  "set-modified": { type: "boolean" },
+  "set-created": { type: "boolean" },
+  recursive: { type: "boolean", short: "r" },
+  "only-ext": { type: "string" },
+  folders: { type: "boolean" },
+  name: { type: "string" },
+  apply: { type: "boolean" },
+  journal: { type: "string" },
+  json: { type: "boolean" },
+  quiet: { type: "boolean", short: "q" },
+  help: { type: "boolean", short: "h" }
+};
+var UNDO_OPTIONS = { help: { type: "boolean", short: "h" } };
+function parsed(run2) {
+  try {
+    return run2();
+  } catch (e) {
+    const code = e.code;
+    if (typeof code === "string" && code.startsWith("ERR_PARSE_ARGS")) {
+      throw new UsageError(e.message.replace(/\s*\n\s*/g, " "));
+    }
+    throw e;
+  }
+}
+var parseRenameArgs = (args) => parsed(() => parseArgs({ args: [...args], options: RENAME_OPTIONS, allowPositionals: true, strict: true }));
+async function parseCommand(argv, cwd, readText = (file) => readFile(file, "utf8")) {
+  const [first, ...rest] = argv;
+  if (first === void 0) return { kind: "help" };
+  if (first === "rename") return parseRename(rest, cwd, readText);
+  if (first === "undo") return parseUndo(rest, cwd);
+  if (first === "tokens") {
+    if (rest[0] !== void 0) throw new UsageError(`tokens takes no arguments, got "${rest[0]}"`);
+    return { kind: "tokens" };
+  }
+  if (argv.length === 1 && (first === "--help" || first === "-h")) return { kind: "help" };
+  if (argv.length === 1 && (first === "--version" || first === "-v")) return { kind: "version" };
+  const flag = argv.find((a) => a.startsWith("-"));
+  if (flag !== void 0) {
+    throw new UsageError(`"${flag}" needs a command; to rename from the terminal use "renami rename <paths\u2026> ${flag}"`);
+  }
+  return { kind: "open", paths: argv.map((p) => path5.resolve(cwd, p)) };
+}
+function parseUndo(args, cwd) {
+  const { values, positionals } = parsed(
+    () => parseArgs({ args: [...args], options: UNDO_OPTIONS, allowPositionals: true, strict: true })
+  );
+  if (values.help) return { kind: "help" };
+  const [journal] = positionals;
+  if (journal === void 0 || positionals.length !== 1) {
+    throw new UsageError("undo needs exactly one journal file: renami undo <journal.json>");
+  }
+  return { kind: "undo", journal: path5.resolve(cwd, journal) };
+}
+async function parseRename(args, cwd, readText) {
+  const { values, positionals } = parseRenameArgs(args);
+  if (values.help) return { kind: "help" };
+  if (positionals.length === 0) throw new UsageError("rename needs at least one file or folder");
+  if (values.journal !== void 0 && !values.apply) throw new UsageError("--journal only works with --apply");
+  const settings = values.settings === void 0 ? withDefaults({}) : await readSettings(path5.resolve(cwd, values.settings), readText);
+  applyFlags(settings, values, cwd);
+  return {
+    kind: "rename",
+    paths: positionals.map((p) => path5.resolve(cwd, p)),
+    settings,
+    options: {
+      apply: values.apply === true,
+      journal: values.journal === void 0 ? null : path5.resolve(cwd, values.journal),
+      json: values.json === true,
+      quiet: values.quiet === true
+    }
+  };
+}
+async function readSettings(file, readText) {
+  let data;
+  try {
+    data = JSON.parse(await readText(file));
+  } catch (e) {
+    throw new UsageError(`can't read the settings file ${file}: ${e.message}`);
+  }
+  if (typeof data !== "object" || data === null || Array.isArray(data)) {
+    throw new UsageError(`the settings file ${file} must hold a JSON object`);
+  }
+  const settings = withDefaults(data);
+  if (settings.sequence.sortBy === "manual") throw new UsageError('sortBy "manual" only works in the desktop app');
+  return settings;
+}
+function applyFlags(s, v, cwd) {
+  if (v.pattern !== void 0) s.pattern = v.pattern;
+  if (v.sort !== void 0) s.sequence.sortBy = choice("--sort", v.sort, SORTS);
+  if (v.desc) s.sequence.direction = "desc";
+  if (v.start !== void 0) s.sequence.start = integer("--start", v.start, 0, 999999999);
+  if (v.step !== void 0) s.sequence.step = integer("--step", v.step, 1, 1e6);
+  if (v.digits !== void 0) s.sequence.digits = integer("--digits", v.digits, 1, 10);
+  if (v.restart !== void 0) s.sequence.restartEvery = choice("--restart", v.restart, RESTARTS);
+  if (v["restart-per-folder"]) s.sequence.restartPerFolder = true;
+  for (const pair of v.replace ?? []) {
+    const [find, replace] = split("--replace", pair, "FIND=REPL");
+    s.findReplace.push({ find, replace, regex: v.regex === true, matchCase: v["match-case"] === true });
+  }
+  if (v.case !== void 0) s.cleanup.caseMode = choice("--case", v.case, CASES);
+  if (v["spaces-to-underscores"]) s.cleanup.spacesToUnderscores = true;
+  if (v.ascii) s.cleanup.asciiOnly = true;
+  if (v["strip-accents"]) s.cleanup.stripDiacritics = true;
+  for (const pair of v.ext ?? []) {
+    const [from, to] = split("--ext", pair, "FROM=TO");
+    s.cleanup.extensionRules.push({ from: normalizeExtension(from), to: normalizeExtension(to) });
+  }
+  if (v.dest !== void 0) s.move.destinationRoot = path5.resolve(cwd, v.dest);
+  if (v.shift !== void 0) s.dates.shiftMinutes = integer("--shift", v.shift, -1e6, 1e6);
+  if (v["use-name-date"]) s.dates.useNameDate = true;
+  if (v["set-modified"]) s.dates.setModified = true;
+  if (v["set-created"]) s.dates.setCreated = true;
+  if (v.recursive) s.filter.includeSubfolders = true;
+  if (v["only-ext"] !== void 0) {
+    const extensions = v["only-ext"].split(",").map(normalizeExtension).filter((e) => e !== "");
+    if (extensions.length === 0) throw new UsageError("--only-ext needs at least one extension");
+    s.filter.extensions = extensions;
+  }
+  if (v.folders) s.filter.mode = "folders";
+  if (v.name !== void 0) s.filter.name = { text: v.name, regex: false };
+}
+function split(flag, value, shape) {
+  const i = value.indexOf("=");
+  if (i <= 0) throw new UsageError(`${flag} needs ${shape}, got "${value}"`);
+  return [value.slice(0, i), value.slice(i + 1)];
+}
+function integer(flag, value, min, max) {
+  const n2 = Number(value);
+  if (!/^[+-]?\d+$/.test(value.trim()) || n2 < min || n2 > max) {
+    throw new UsageError(`${flag} needs a whole number from ${min} to ${max}, got "${value}"`);
+  }
+  return n2;
+}
+function choice(flag, value, options) {
+  const match = options.find((o) => o === value);
+  if (match === void 0) throw new UsageError(`${flag} must be one of ${options.join(", ")}; got "${value}"`);
+  return match;
+}
+
+// src/cli/exit.ts
+var EXIT = {
+  ok: 0,
+  usage: 1,
+  patternError: 2,
+  planErrors: 3,
+  stale: 4,
+  failed: 5,
+  undoSkipped: 6,
+  appNotFound: 7
+};
+
+// src/cli/launch.ts
+import { execFile as execFile2, spawn } from "node:child_process";
+import { access } from "node:fs/promises";
+import path6 from "node:path";
+import { promisify as promisify2 } from "node:util";
+var WINDOWS_INSTALL_KEY = "Software\\09c3bcba-8eb4-57fd-a1c8-89a5efb9a1ed";
+var LINUX_APP = "/opt/Renami/renami-app";
+function parseRegValue(stdout) {
+  return /InstallLocation\s+REG_\w+\s+(.+?)\s*$/m.exec(stdout)?.[1] ?? null;
+}
+async function windowsApp(deps) {
+  for (const root of ["HKCU", "HKLM"]) {
+    const dir = await deps.installLocation(root, WINDOWS_INSTALL_KEY);
+    const file = dir ? path6.win32.join(dir, "Renami.exe") : null;
+    if (file && await deps.exists(file)) return file;
+  }
+  const { LOCALAPPDATA, ProgramFiles } = deps.env;
+  const defaults = [
+    LOCALAPPDATA && path6.win32.join(LOCALAPPDATA, "Programs", "Renami", "Renami.exe"),
+    ProgramFiles && path6.win32.join(ProgramFiles, "Renami", "Renami.exe")
+  ];
+  for (const file of defaults) if (file && await deps.exists(file)) return file;
+  return null;
+}
+async function openInApp(paths, deps) {
+  if (deps.platform === "darwin") return await deps.run("open", ["-a", "Renami", ...paths]) === 0;
+  const app = deps.platform === "win32" ? await windowsApp(deps) : await deps.exists(LINUX_APP) ? LINUX_APP : null;
+  return app !== null && deps.start(app, [...paths]);
+}
+var execFileAsync = promisify2(execFile2);
+function systemLaunchDeps() {
+  return {
+    platform: process.platform,
+    env: process.env,
+    exists: (file) => access(file).then(
+      () => true,
+      () => false
+    ),
+    installLocation: async (root, key) => {
+      try {
+        const { stdout } = await execFileAsync("reg", ["query", `${root}\\${key}`, "/v", "InstallLocation"], {
+          windowsHide: true
+        });
+        return parseRegValue(stdout);
+      } catch {
+        return null;
+      }
+    },
+    start: (file, args) => new Promise((resolve) => {
+      const child = spawn(file, args, { detached: true, stdio: "ignore" });
+      child.once("error", () => resolve(false));
+      child.once("spawn", () => {
+        child.unref();
+        resolve(true);
+      });
+    }),
+    run: (file, args) => new Promise((resolve) => {
+      const child = spawn(file, args, { stdio: "ignore" });
+      child.once("error", () => resolve(null));
+      child.once("exit", (code) => resolve(code));
+    })
+  };
+}
+
+// src/cli/run.ts
+import { lstat as lstat3, rename as rename3, unlink as unlink3, writeFile as writeFile2 } from "node:fs/promises";
+import path8 from "node:path";
+
+// src/cli/help.ts
+var HELP = `Rename files in bulk from a pattern.
+
+Usage:
+  renami rename <paths\u2026> [options]   Show what would be renamed (a dry run)
+  renami rename <paths\u2026> --apply     Rename the files
+  renami undo <journal.json>         Undo a rename recorded with --journal
+  renami tokens                      List the tokens a pattern can use
+  renami <paths\u2026>                    Open the Renami desktop app with these files
+  renami --help | --version
+
+Options for rename:
+  -p, --pattern <pattern>       The new name, e.g. "Trip_{date_taken:YYYY-MM-DD}_{seq:3}"
+      --settings <file.json>    Settings saved as JSON; the flags below override them
+
+  Numbering
+      --sort dateTaken|created|modified|name   --desc
+      --start N   --step N   --digits N
+      --restart never|day|month|year           --restart-per-folder
+
+  Find & replace (in the current name)
+      --replace FIND=REPL       Repeatable; plain text unless --regex
+      --regex   --match-case
+
+  Clean up
+      --case none|lower|upper|title|sentence|snake|kebab|camel
+      --spaces-to-underscores   --ascii   --strip-accents
+      --ext FROM=TO             Map an extension, e.g. --ext jpeg=jpg (repeatable)
+
+  Move and dates
+      --dest <folder>           Move the renamed files into this folder
+      --shift=<\xB1minutes>        Correct a wrong camera clock, e.g. --shift=-60
+      --use-name-date           Use a date in the file name when there is no date taken
+      --set-modified   --set-created   Set the file's dates to the date used
+
+  Which files
+  -r, --recursive               Include subfolders
+      --only-ext jpg,heic       Only these extensions
+      --folders                 Rename the folders inside the given folders
+      --name <text>             Only names containing this text
+
+  Output and safety
+      --apply                   Rename (without it, nothing on disk changes)
+      --journal <file.json>     With --apply: record the batch so "renami undo" can reverse it
+      --json                    Print the plan and the result as JSON
+  -q, --quiet                   Print only errors
+
+Exit codes:
+  0   Done, or a dry run found no problems
+  1   Usage error
+  2   Invalid pattern
+  3   Some files can't be renamed; nothing was renamed
+  4   Files changed between the plan and the rename; nothing was renamed
+  5   The rename or undo failed or was cancelled, or the journal couldn't be written
+  6   The undo skipped some files
+  7   The desktop app was not found
+`;
+function tokensText() {
+  const lines = Object.entries(TOKENS).map(([name, def]) => `  ${`{${name}}`.padEnd(18)}${def.label}`);
+  return `${lines.join("\n")}
+
+Dates take a format: {date_taken:YYYY-MM-DD}. Numbers take digits: {seq:3}.
+`;
+}
+
+// src/cli/journal.ts
+import { readFile as readFile2, rename as rename2, unlink as unlink2, writeFile } from "node:fs/promises";
+var JOURNAL_VERSION = 1;
+var JournalError = class extends Error {
+  constructor(message2) {
+    super(message2);
+    this.name = "JournalError";
+  }
+};
+async function writeJournal(file, record) {
+  const tmp = `${file}.${process.pid}.tmp`;
+  const body = { version: JOURNAL_VERSION, tool: "renami", record };
+  try {
+    await writeFile(tmp, `${JSON.stringify(body, null, 2)}
+`, { encoding: "utf8", flag: "wx" });
+    await rename2(tmp, file);
+  } catch (e) {
+    await unlink2(tmp).catch(() => void 0);
+    throw e;
+  }
+}
+async function readJournal(file) {
+  let data;
+  try {
+    data = JSON.parse(await readFile2(file, "utf8"));
+  } catch (e) {
+    throw new JournalError(`can't read the journal ${file}: ${e.message}`);
+  }
+  if (!isObject2(data) || data.tool !== "renami") throw new JournalError(`${file} is not a renami journal`);
+  if (data.version !== JOURNAL_VERSION) {
+    throw new JournalError(`${file} is a version ${String(data.version)} journal; this renami reads version ${JOURNAL_VERSION}`);
+  }
+  if (!isRecord(data.record)) throw new JournalError(`${file} is damaged: its batch record is incomplete`);
+  return data.record;
+}
+var isObject2 = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+var isNumber = (v) => typeof v === "number" && Number.isFinite(v);
+var isTimes = (v) => v === null || isObject2(v) && isNumber(v.atimeMs) && isNumber(v.mtimeMs) && (v.birthtimeMs === null || isNumber(v.birthtimeMs));
+var isFile = (v) => isObject2(v) && typeof v.from === "string" && typeof v.to === "string" && isNumber(v.sizeAfter) && isNumber(v.mtimeMsAfter) && isTimes(v.originalTimes);
+var isRecord = (v) => isObject2(v) && typeof v.id === "string" && Array.isArray(v.files) && v.files.every(isFile) && Array.isArray(v.createdDirs) && v.createdDirs.every((d) => typeof d === "string") && isNumber(v.finishedAt);
+
+// src/cli/render.ts
+import path7 from "node:path";
+var plural = (n2, word) => `${n2} ${word}${n2 === 1 ? "" : "s"}`;
+function shown(p, cwd) {
+  const rel = path7.relative(cwd, p);
+  return rel !== "" && !rel.startsWith("..") && !path7.isAbsolute(rel) ? rel : p;
+}
+var wallClockText = (w) => formatWallClock(w, "YYYY-MM-DDTHH:mm:ss");
+function summarize(plan) {
+  let toRename = 0;
+  let unchanged = 0;
+  let warnings = 0;
+  for (const item of plan.items) {
+    if (isMoving(item.kind)) toRename += 1;
+    else if (item.kind === "unchanged") unchanged += 1;
+    if (item.flags.some((f) => f.level === "warning")) warnings += 1;
+  }
+  return { total: plan.items.length, toRename, unchanged, warnings, errors: plan.errorCount };
+}
+function summaryLine(s) {
+  const parts = [`${s.toRename} to rename`, `${s.unchanged} unchanged`];
+  if (s.warnings > 0) parts.push(plural(s.warnings, "warning"));
+  parts.push(plural(s.errors, "error"));
+  return parts.join(", ");
+}
+function planText(plan, cwd) {
+  const lines = [];
+  for (const item of plan.items) {
+    const from = shown(item.source.path, cwd);
+    if (isMoving(item.kind)) lines.push(`${from} -> ${shown(item.target, cwd)}`);
+    else if (item.kind === "error") lines.push(`${from} (not renamed)`);
+    else lines.push(`${from} (unchanged)`);
+    for (const f of item.flags) if (f.level !== "info") lines.push(`    ${f.level}: ${f.message}`);
+  }
+  lines.push(summaryLine(summarize(plan)));
+  return `${lines.join("\n")}
+`;
+}
+function planJson(plan, result) {
+  const body = {
+    plan: plan.items.map((i) => ({
+      source: i.source.path,
+      target: i.target,
+      kind: i.kind,
+      flags: i.flags.map(({ level, code, message: message2 }) => ({ level, code, message: message2 })),
+      dateUsed: i.dateUsed ? { value: wallClockText(i.dateUsed.value), source: i.dateUsed.source } : null
+    })),
+    patternError: plan.patternError,
+    summary: summarize(plan),
+    ...result ? { result } : {}
+  };
+  return `${JSON.stringify(body, null, 2)}
+`;
+}
+function rollbackText(report, cwd) {
+  if (report.complete) return "Every file was put back.";
+  const lines = report.stranded.map((s) => `  ${shown(s.current, cwd)} (was ${shown(s.original, cwd)})`);
+  return `These files could not be put back:
+${lines.join("\n")}`;
+}
+function resultText(result, cwd) {
+  switch (result.status) {
+    case "done": {
+      const dates = result.datesChanged > 0 ? `, set dates on ${plural(result.datesChanged, "file")}` : "";
+      const undo = result.journal ? `
+Undo with: renami undo "${shown(result.journal, cwd)}"` : "";
+      return `Renamed ${plural(result.renamed, "file")}${dates}.${undo}
+`;
+    }
+    case "stale":
+      return `Nothing was renamed: these files changed after the plan was made. Run it again.
+${result.changed.map((p) => `  ${shown(p, cwd)}`).join("\n")}
+`;
+    case "cancelled":
+      return `Cancelled. ${rollbackText(result.rollback, cwd)}
+`;
+    case "failed":
+      return `The rename failed: ${result.error ?? "unknown error"}. ${rollbackText(result.rollback, cwd)}
+`;
+  }
+}
+
+// src/cli/run.ts
+var exists2 = (p) => lstat3(p).then(
+  () => true,
+  () => false
+);
+var CANCELLED = "cancelled; nothing was renamed";
+var message = (e) => e instanceof Error ? e.message : String(e);
+var fail2 = (ctx, text2) => {
+  ctx.stderr.write(`renami: ${text2}
+`);
+};
+async function runCommand(command, ctx) {
+  switch (command.kind) {
+    case "help":
+      ctx.stdout.write(HELP);
+      return EXIT.ok;
+    case "version":
+      ctx.stdout.write(`${ctx.version}
+`);
+      return EXIT.ok;
+    case "tokens":
+      ctx.stdout.write(tokensText());
+      return EXIT.ok;
+    case "open":
+      return runOpen(command.paths, ctx);
+    case "undo":
+      return runUndo(command.journal, ctx);
+    case "rename": {
+      const reader = ctx.createReader();
+      try {
+        return await runRename(command, reader, ctx);
+      } finally {
+        await reader.end();
+      }
+    }
+  }
+}
+async function runOpen(paths, ctx) {
+  if (await openInApp(paths, ctx.launch)) return EXIT.ok;
+  const appImage = ctx.launch.platform === "linux" ? " (an AppImage cannot be found this way; start it with the paths instead)" : "";
+  fail2(ctx, `Renami desktop app not found${appImage}; to rename from the terminal use "renami rename <paths\u2026>"`);
+  return EXIT.appNotFound;
+}
+var progressOf = (ctx, label) => (done, total) => {
+  if (done === total || done % 25 === 0) ctx.progress?.(`${label} ${done}/${total}`);
+};
+async function runRename({ paths, settings, options }, reader, ctx) {
+  const found = await Promise.all(paths.map(exists2));
+  const missing = paths.find((_, i) => !found[i]);
+  if (missing !== void 0) {
+    fail2(ctx, `no such file or folder: ${missing}`);
+    return EXIT.usage;
+  }
+  if (options.journal !== null) {
+    if (await exists2(options.journal)) {
+      fail2(ctx, `the journal ${options.journal} already exists; pick a new file name`);
+      return EXIT.usage;
+    }
+    const probe = `${options.journal}.${process.pid}.check`;
+    try {
+      await writeFile2(probe, "", { flag: "wx" });
+      await unlink3(probe);
+    } catch (e) {
+      await unlink3(probe).catch(() => void 0);
+      const dir = path8.dirname(options.journal);
+      const missingDir = e.code === "ENOENT";
+      fail2(ctx, missingDir ? `the journal's folder doesn't exist: ${dir}` : `can't write the journal in ${dir}: ${message(e)}`);
+      return EXIT.usage;
+    }
+  }
+  const timeZone = ctx.timeZone ?? systemTimeZone();
+  const { entries, unreadableFolders } = await scan(paths, settings.filter);
+  for (const dir of unreadableFolders) fail2(ctx, `couldn't read the folder ${dir}; its files are left out`);
+  const metadata = /* @__PURE__ */ new Map();
+  const readProgress = progressOf(ctx, "Reading file details");
+  const read = await readMetadata(entries, reader, {
+    signal: ctx.signal,
+    onResult: (p, meta) => {
+      metadata.set(p, meta);
+      readProgress(metadata.size, entries.length);
+    }
+  });
+  ctx.progress?.(null);
+  if ("error" in read) {
+    fail2(ctx, `reading file details stopped: ${message(read.error)}`);
+    return EXIT.failed;
+  }
+  if (ctx.signal.aborted) {
+    fail2(ctx, CANCELLED);
+    return EXIT.failed;
+  }
+  if (read.exiftoolFailed) fail2(ctx, "ExifTool isn't working, so files without details use their file system dates");
+  let allMetadata = metadata;
+  if (patternUsesHash(settings.pattern)) {
+    const hashes = new HashCache(timeZone);
+    await hashes.hashMissing(entries, ctx.signal);
+    if (ctx.signal.aborted) {
+      fail2(ctx, CANCELLED);
+      return EXIT.failed;
+    }
+    allMetadata = hashes.mergeInto(metadata, entries);
+  }
+  const plan = buildPlan({ entries, metadata: allMetadata, settings, fs: createFsView(), platform: ctx.platform, timeZone });
+  const showJson = (result2) => {
+    if (options.json) ctx.stdout.write(planJson(plan, result2));
+  };
+  if (plan.patternError !== null) {
+    showJson();
+    fail2(ctx, plan.patternError);
+    return EXIT.patternError;
+  }
+  if (!options.json && !options.quiet) {
+    ctx.stdout.write(entries.length === 0 ? "Nothing to rename: no files matched.\n" : planText(plan, ctx.cwd));
+  }
+  if (plan.errorCount > 0) {
+    showJson();
+    fail2(ctx, `${plural(plan.errorCount, "file")} can't be renamed${options.apply ? "; nothing was renamed" : ""}`);
+    return EXIT.planErrors;
+  }
+  if (!options.apply) {
+    showJson();
+    return EXIT.ok;
+  }
+  const batch = await executePlan(plan, {
+    signal: ctx.signal,
+    onProgress: progressOf(ctx, "Renaming"),
+    birthtime: ctx.birthtime
+  });
+  ctx.progress?.(null);
+  let result;
+  let journalFailed = false;
+  if (batch.status === "done") {
+    const { files } = batch.record;
+    let journal = null;
+    if (options.journal !== null && files.length === 0) {
+      fail2(ctx, "nothing changed, so no journal was written");
+    } else if (options.journal !== null) {
+      try {
+        await writeJournal(options.journal, batch.record);
+        journal = options.journal;
+      } catch (e) {
+        journalFailed = true;
+        fail2(ctx, `the files were renamed, but the journal couldn't be written: ${message(e)}`);
+      }
+    }
+    result = {
+      status: "done",
+      renamed: files.filter((f) => f.from !== f.to).length,
+      datesChanged: files.filter((f) => f.originalTimes !== null).length,
+      journal
+    };
+  } else if (batch.status === "stale") {
+    result = { status: "stale", changed: batch.changed };
+  } else {
+    result = { status: batch.status, error: batch.error, rollback: batch.rollback };
+  }
+  showJson(result);
+  if (!options.json) {
+    if (result.status !== "done") ctx.stderr.write(`renami: ${resultText(result, ctx.cwd)}`);
+    else if (!options.quiet) ctx.stdout.write(resultText(result, ctx.cwd));
+  }
+  if (result.status === "done") return journalFailed ? EXIT.failed : EXIT.ok;
+  return result.status === "stale" ? EXIT.stale : EXIT.failed;
+}
+async function runUndo(journal, ctx) {
+  if (!await exists2(journal)) {
+    fail2(ctx, await exists2(`${journal}.undone`) ? `${journal} was already undone` : `no such journal: ${journal}`);
+    return EXIT.usage;
+  }
+  let record;
+  try {
+    record = await readJournal(journal);
+  } catch (e) {
+    if (!(e instanceof JournalError)) throw e;
+    fail2(ctx, e.message);
+    return EXIT.usage;
+  }
+  const history = new History();
+  history.push(record);
+  const result = await history.undo({ signal: ctx.signal, birthtime: ctx.birthtime });
+  for (const s of result.skipped) fail2(ctx, `skipped ${shown(s.path, ctx.cwd)}: ${s.reason}`);
+  if (result.status === "done") {
+    await rename3(journal, `${journal}.undone`);
+    ctx.stdout.write(`Put back ${plural(result.restored, "file")}.
+`);
+    return result.skipped.length > 0 ? EXIT.undoSkipped : EXIT.ok;
+  }
+  const what = result.status === "cancelled" ? "undo cancelled" : `undo failed: ${result.error ?? "unknown error"}`;
+  fail2(ctx, result.rollback ? `${what}. ${rollbackText(result.rollback, ctx.cwd)}` : what);
+  return EXIT.failed;
+}
+
+// src/cli/main.ts
+var VERSION = "0.2.2";
+async function main() {
+  const controller = new AbortController();
+  process.on("SIGINT", () => {
+    if (controller.signal.aborted) process.exit(130);
+    process.stderr.write("\nrenami: stopping; press Ctrl-C again to quit at once\n");
+    controller.abort();
+  });
+  let command;
+  try {
+    command = await parseCommand(process.argv.slice(2), process.cwd());
+  } catch (e) {
+    if (!(e instanceof UsageError)) throw e;
+    process.stderr.write(`renami: ${e.message}
+renami: run "renami --help" for usage
+`);
+    return EXIT.usage;
+  }
+  const tty = process.stderr.isTTY;
+  return runCommand(command, {
+    stdout: process.stdout,
+    stderr: process.stderr,
+    signal: controller.signal,
+    cwd: process.cwd(),
+    platform: process.platform,
+    version: VERSION,
+    createReader: () => new MetadataReader(),
+    launch: systemLaunchDeps(),
+    progress: tty ? (text2) => process.stderr.write(text2 === null ? "\r\x1B[K" : `\r${text2}\x1B[K`) : void 0
+  });
+}
+main().then(
+  (code) => {
+    process.exitCode = code;
+  },
+  (e) => {
+    process.stderr.write(`renami: ${e instanceof Error ? e.message : String(e)}
+`);
+    process.exitCode = EXIT.failed;
+  }
+);