@kitschpatrol/aphex 0.1.0

package/dist/index.js

@@ -0,0 +1,1989 @@
+import fse from "fs-extra";
+import path, { dirname } from "node:path";
+import is, { assert, isNonEmptyStringAndNotWhitespace } from "@sindresorhus/is";
+import { execa } from "execa";
+import { spawn } from "node:child_process";
+import { ExifTool } from "exiftool-vendored";
+import { createLogger, injectionHelper } from "lognow";
+import os from "node:os";
+import { slug } from "github-slugger";
+import { fileURLToPath } from "node:url";
+import { createDefu } from "defu";
+import { imageSizeFromFile } from "image-size/fromFile";
+import { lookup, mimes } from "mrmime";
+import { Piscina } from "piscina";
+import { deepEqual } from "fast-equals";
+//#endregion
+//#region src/utilities/log.ts
+/**
+* The default logger instance for the library.
+*/
+let log = createLogger("@kitschpatrol/aphex");
+/**
+* Set the logger instance for the module.
+* Export this for library consumers to inject their own logger.
+* @param logger - Accepts either a LogLayer instance or a Console- or Stream-like log target
+*/
+function setLogger(logger) {
+	log = injectionHelper(logger);
+}
+//#endregion
+//#region src/utilities/exiftool.ts
+/**
+* Centralized exiftool instance management
+*
+* This module provides a managed exiftool instance with proper lifecycle
+* management to prevent hanging processes. The exiftool-vendored library
+* spawns persistent Perl processes that must be explicitly ended.
+*/
+const exiftoolInstance = new ExifTool({
+	maxProcs: 4,
+	onIdleIntervalMillis: 1e3
+});
+let cleanupScheduled = false;
+let processExitHandlerInstalled = false;
+/**
+* Get the managed exiftool instance
+*/
+function getExiftool() {
+	scheduleProcessCleanup();
+	return exiftoolInstance;
+}
+/**
+* End the exiftool process gracefully
+*
+* This should be called when you're done using exiftool to prevent
+* hanging processes. It's safe to call multiple times.
+*/
+async function endExiftool() {
+	if (exiftoolInstance.pids.length > 0) {
+		log.debug(`Ending exiftool processes: ${exiftoolInstance.pids.join(", ")}`);
+		await exiftoolInstance.end();
+		log.debug("Exiftool processes ended");
+	}
+}
+/**
+* Install process exit handlers for automatic cleanup
+*
+* This ensures exiftool processes are cleaned up even if the user
+* forgets to call endExiftool(). Only installs handlers once.
+*/
+function scheduleProcessCleanup() {
+	if (processExitHandlerInstalled) return;
+	processExitHandlerInstalled = true;
+	process.on("beforeExit", async () => {
+		if (!cleanupScheduled) {
+			cleanupScheduled = true;
+			await endExiftool();
+		}
+	});
+	process.on("exit", () => {
+		if (exiftoolInstance.pids.length > 0) log.debug(`Exiftool processes still running at exit: ${exiftoolInstance.pids.join(", ")}`);
+	});
+	process.on("SIGINT", async () => {
+		log.debug("Received SIGINT, cleaning up exiftool...");
+		await endExiftool();
+		process.exit(130);
+	});
+	process.on("SIGTERM", async () => {
+		log.debug("Received SIGTERM, cleaning up exiftool...");
+		await endExiftool();
+		process.exit(143);
+	});
+}
+//#endregion
+//#region src/utilities/file.ts
+/**
+* Removes the file extension from a file path
+*/
+function stripExtension(filePath) {
+	return path.join(path.dirname(filePath), path.basename(filePath, path.extname(filePath)));
+}
+/**
+* Gets the size of a file in bytes
+*/
+async function getSizeBytes(filePath) {
+	const { size } = await fse.stat(filePath);
+	return size;
+}
+/**
+* Normalizes file extensions, particularly for image files
+* Converts to lowercase.
+* Converts .jpg to .jpeg and .tif to .tiff
+*/
+function normalizeExtension(filePath) {
+	const directory = path.dirname(filePath);
+	const fileExtension = path.extname(filePath).toLowerCase();
+	const fileBase = path.basename(filePath, path.extname(filePath));
+	switch (fileExtension) {
+		case ".jpg": return path.join(directory, `${fileBase}.jpeg`);
+		case ".tif": return path.join(directory, `${fileBase}.tiff`);
+		default: return path.join(directory, `${fileBase}${fileExtension}`);
+	}
+}
+/**
+* Converts a filename to a GitHub-style slug format
+* @param filePath - The path of the file
+* @returns The slug version of the filename without extension
+*/
+function getSlugFilename(filePath) {
+	return slug(path.basename(filePath, path.extname(filePath)));
+}
+/**
+* Ensures the directory for a given file path exists, creating it if necessary.
+* Expands '~' to the user's home directory.
+* @param filePath - The full file path for which to ensure the directory exists
+* @returns The fully expanded directory path which definitely exists
+*/
+async function ensureDirectoryExists(filePath) {
+	const expandedDirectory = filePath.startsWith("~") ? path.join(os.homedir(), filePath.slice(1)) : filePath;
+	await fse.ensureDir(expandedDirectory);
+	return expandedDirectory;
+}
+/**
+* Creates a temporary directory with an optional custom prefix based on provided labels
+*/
+async function getTempDirectory(...labels) {
+	const prefix = labels.length > 0 ? `com.kitschpatrol.aphex.${labels.map((l) => l.toLowerCase()).join(".")}.` : "com.kitschpatrol.aphex.";
+	return fse.mkdtemp(path.join(os.tmpdir(), prefix));
+}
+//#endregion
+//#region src/utilities/general.ts
+const UUID_REGEX = /^[\da-f]{8}(?:-[\da-f]{4}){3}-[\da-f]{12}$/i;
+/**
+* Sips makes a mess of the temp folder and does not respect TMPDIR, so we need
+* to clean up after it ourselves
+*/
+async function sipsTempCleanup() {
+	const uuidFiles = fse.readdirSync(os.tmpdir()).filter((file) => UUID_REGEX.test(file));
+	let cleanCount = 0;
+	for (const file of uuidFiles) {
+		const filePath = path.join(os.tmpdir(), file);
+		const { stdout } = await execa("file", [
+			"-b",
+			"--mime",
+			filePath
+		]);
+		if (stdout.startsWith("image/")) {
+			await fse.rm(filePath, { force: true });
+			cleanCount += 1;
+		}
+	}
+	return cleanCount;
+}
+/**
+* Ensure the value is an array. If it's undefined or null, return an empty
+* array.
+*/
+function ensureArray(value) {
+	if (value === void 0 || value === null) return [];
+	return Array.isArray(value) ? value : [value];
+}
+/**
+* Ensure the length has a single item
+*/
+function assertSingleElement(array) {
+	if (array.length !== 1) throw new Error(`Expected array of length 1, got ${array.length}`);
+}
+//#endregion
+//#region src/utilities/paths.ts
+/**
+* import.meta.dirname for Node >= 20.19.0
+* @example getDirname(import.meta)
+*/
+function getDirname(meta) {
+	return dirname(fileURLToPath(process.env.PISCINA_WORKER_META_URL ?? meta.url));
+}
+/**
+* Asset directory path of package or distribution folder (Copied by tsdown)
+*/
+function getPackageAssetsPath(meta) {
+	const dirname = getDirname(meta);
+	return path.basename(dirname) === "dist" ? path.join(dirname, "assets") : path.join("src", "assets");
+}
+/**
+* Asset directory path of package or distribution folder (Copied by tsdown)
+*/
+function getPackageWorkersPath(meta) {
+	const dirname = getDirname(meta);
+	return path.basename(dirname) === "dist" ? path.join(dirname, "workers") : path.join(dirname, "..", "workers");
+}
+/**
+* Binary directory path of package or distribution folder (Copied by native build script)
+*/
+function getPackageBinPath(meta) {
+	const dirname = getDirname(meta);
+	return path.basename(dirname) === "dist" ? path.join(dirname) : path.join("dist");
+}
+//#endregion
+//#region src/aphex-swift/cli-bridge.ts
+const SHELL_SPECIAL_CHARS_REGEX = /[\s'"\\]/;
+let interactiveProcess;
+let currentRequest;
+/**
+* Start an interactive session with aphex-swift.
+* Commands will be sent to this persistent process instead of spawning new ones.
+* @throws {Error} If the session is already active or fails to start
+*/
+async function interactiveSessionStart() {
+	if (interactiveProcess !== void 0) throw new Error("Interactive session is already active");
+	interactiveProcess = spawn("./aphex-swift", ["interactive"], {
+		cwd: getPackageBinPath(import.meta),
+		stdio: [
+			"pipe",
+			"pipe",
+			"pipe"
+		]
+	});
+	interactiveProcess.stdout?.on("data", (data) => {
+		if (currentRequest === void 0) return;
+		currentRequest.buffer += data.toString();
+		try {
+			JSON.parse(currentRequest.buffer);
+			const response = currentRequest.buffer;
+			const request = currentRequest;
+			currentRequest = void 0;
+			request.resolve(response);
+			processNextCommand();
+		} catch {}
+	});
+	interactiveProcess.stderr?.on("data", (data) => {
+		if (currentRequest !== void 0) {
+			const error = new Error(data.toString().trim());
+			const request = currentRequest;
+			currentRequest = void 0;
+			request.reject(error);
+			processNextCommand();
+		}
+	});
+	interactiveProcess.on("close", (code) => {
+		const error = /* @__PURE__ */ new Error(`Interactive session exited with code ${code}`);
+		if (currentRequest !== void 0) {
+			currentRequest.reject(error);
+			currentRequest = void 0;
+		}
+		for (const queued of commandQueue) queued.reject(error);
+		commandQueue = [];
+		interactiveProcess = void 0;
+	});
+	await new Promise((resolve) => {
+		setTimeout(resolve, 100);
+	});
+}
+/**
+* Stop the interactive session if one is active.
+*/
+async function interactiveSessionStop() {
+	if (interactiveProcess === void 0) return;
+	const processToStop = interactiveProcess;
+	processToStop.stdin?.write("exit\n");
+	processToStop.stdin?.end();
+	await new Promise((resolve) => {
+		processToStop.on("close", () => {
+			resolve();
+		});
+		setTimeout(() => {
+			processToStop.kill("SIGKILL");
+			resolve();
+		}, 1e3);
+	});
+	interactiveProcess = void 0;
+	currentRequest = void 0;
+	commandQueue = [];
+	await endExiftool();
+}
+/**
+* Check if an interactive session is currently active
+*/
+function isInteractiveSessionActive() {
+	return interactiveProcess !== void 0;
+}
+let commandQueue = [];
+function processNextCommand() {
+	if (currentRequest !== void 0 || commandQueue.length === 0 || interactiveProcess === void 0) return;
+	const next = commandQueue.shift();
+	currentRequest = {
+		buffer: "",
+		reject: next.reject,
+		resolve: next.resolve
+	};
+	interactiveProcess.stdin?.write(next.command + "\n");
+}
+/**
+* Send a command to the interactive session and wait for the response
+*/
+async function executeInteractiveCommand(command) {
+	if (interactiveProcess === void 0) throw new Error("No interactive session active");
+	return new Promise((resolve, reject) => {
+		commandQueue.push({
+			command,
+			reject,
+			resolve
+		});
+		processNextCommand();
+	});
+}
+/**
+* Escape and join arguments into a single command string for interactive mode.
+* Arguments with spaces or special characters are quoted.
+*/
+function escapeCommand(args) {
+	return args.map((arg) => {
+		if (SHELL_SPECIAL_CHARS_REGEX.test(arg)) return `'${arg.replaceAll("'", String.raw`'\''`)}'`;
+		return arg;
+	}).join(" ");
+}
+/**
+* Runtime type guard for ResourceInfo
+*/
+function isResourceInfo(value) {
+	if (!is.plainObject(value)) return false;
+	const object = value;
+	return is.string(object.contentType) && is.string(object.fileName) && is.string(object.filePath) && is.number(object.fileSize) && is.number(object.height) && is.number(object.width);
+}
+/**
+* Runtime type guard for PhotoInfo
+*/
+function isPhotoInfo(value) {
+	if (!is.plainObject(value)) return false;
+	const object = value;
+	if (!is.string(object.uuid) || !is.boolean(object.favorite) || !is.boolean(object.hidden) || !isResourceInfo(object.original) || !is.date(object.dateCreated) || !is.date(object.dateModified)) return false;
+	if (object.title !== void 0 && !is.string(object.title) || object.edited !== void 0 && !isResourceInfo(object.edited)) return false;
+	return true;
+}
+/**
+* Runtime type guard for PhotoInfo array
+*/
+function isPhotoInfoArray(value) {
+	return is.array(value) && value.every((element) => isPhotoInfo(element));
+}
+/**
+* Runtime type guard for AlbumInfo
+*/
+function isAlbumInfo(value) {
+	if (!is.plainObject(value)) return false;
+	const object = value;
+	if (!is.string(object.uuid) || !is.number(object.type) || !is.number(object.subtype) || !is.number(object.estimatedAssetCount) || !is.string(object.title) || !is.string(object.path)) return false;
+	if (object.dateStart !== void 0 && !is.date(object.dateStart) || object.dateEnd !== void 0 && !is.date(object.dateEnd)) return false;
+	return true;
+}
+/**
+* Assert that a value is an array of PhotoInfo
+*/
+function assertPhotoInfoArray(value) {
+	if (!isPhotoInfoArray(value)) throw new Error("Invalid PhotoInfo array");
+}
+/**
+* Runtime type guard for AlbumInfo array
+*/
+function isAlbumInfoArray(value) {
+	return is.array(value) && value.every((element) => isAlbumInfo(element));
+}
+/**
+* Assert that a value is an AlbumInfo array
+*/
+function assertAlbumInfoArray(value) {
+	if (!isAlbumInfoArray(value)) throw new Error("Invalid AlbumInfo array");
+}
+/**
+* Get photo asset information for given identifiers (ID, filename, album name, or photo path)
+* @throws {Error} If the command fails
+*/
+async function aphexPhotoInfo(identifiers, caseSensitive = false) {
+	const identifiersArray = ensureArray(identifiers);
+	if (identifiersArray.length === 0) return [];
+	const args = [
+		"photo-info",
+		...identifiersArray,
+		...caseSensitive ? ["--case-sensitive"] : []
+	];
+	let stdout;
+	if (isInteractiveSessionActive()) stdout = await executeInteractiveCommand(escapeCommand(args));
+	else stdout = (await execa("./aphex-swift", args, { cwd: getPackageBinPath(import.meta) })).stdout;
+	try {
+		const output = JSON.parse(stdout, dateReviver$1);
+		assertPhotoInfoArray(output);
+		return output;
+	} catch {
+		throw new Error(`Error fetching photos: ${stdout}`);
+	}
+}
+/**
+* Get album info
+* @throws {Error} If the command fails
+*/
+async function aphexAlbumInfo(identifiers, caseSensitive = false) {
+	const identifiersArray = ensureArray(identifiers);
+	if (identifiersArray.length === 0) return [];
+	const args = [
+		"album-info",
+		...identifiersArray,
+		...caseSensitive ? ["--case-sensitive"] : []
+	];
+	let stdout;
+	if (isInteractiveSessionActive()) stdout = await executeInteractiveCommand(escapeCommand(args));
+	else stdout = (await execa("./aphex-swift", args, { cwd: getPackageBinPath(import.meta) })).stdout;
+	try {
+		const output = JSON.parse(stdout, dateReviver$1);
+		assertAlbumInfoArray(output);
+		return output;
+	} catch {
+		throw new Error(`Error fetching album info: ${stdout}`);
+	}
+}
+/**
+* Export photos for given identifiers to a destination directory
+* @throws {Error} If the command fails
+*/
+async function aphexExport(identifiers, destination, caseSensitive = false, originals = false) {
+	const identifiersArray = ensureArray(identifiers);
+	if (identifiersArray.length === 0) return [];
+	const args = [
+		"export",
+		...identifiersArray,
+		"--destination",
+		destination,
+		...caseSensitive ? ["--case-sensitive"] : [],
+		...originals ? ["--originals"] : []
+	];
+	let stdout;
+	if (isInteractiveSessionActive()) stdout = await executeInteractiveCommand(escapeCommand(args));
+	else stdout = (await execa("./aphex-swift", args, { cwd: getPackageBinPath(import.meta) })).stdout;
+	try {
+		const output = JSON.parse(stdout, dateReviver$1);
+		assert.array(output);
+		return output;
+	} catch {
+		throw new Error(`Error exporting: ${stdout}`);
+	}
+}
+function dateReviver$1(key, value) {
+	if ((key === "dateCreated" || key === "dateModified" || key === "dateStart" || key === "dateEnd") && typeof value === "string") return value ? new Date(value) : void 0;
+	return value;
+}
+//#endregion
+//#region src/aphex-swift/identifiers.ts
+/**
+* Takes a mix of photos, albums, strings, all resolved to a single array of PhotoInfo objects
+*/
+async function resolveIdentifiers(identifiers) {
+	const photoInfos = identifiers.filter((identifier) => isPhotoInfo(identifier));
+	const identifierAlbumUuids = identifiers.filter((identifier) => isAlbumInfo(identifier)).map((identifier) => identifier.uuid);
+	const identifierStrings = identifiers.filter((identifier) => typeof identifier === "string");
+	photoInfos.push(...await aphexPhotoInfo([...identifierAlbumUuids, ...identifierStrings]));
+	if (photoInfos.length === 0) throw new Error(`No photos found for identifiers "${identifiers.map((identifier) => JSON.stringify(identifier)).join(", ")}"`);
+	const seen = /* @__PURE__ */ new Set();
+	return photoInfos.filter((photo) => {
+		if (seen.has(photo.uuid)) return false;
+		seen.add(photo.uuid);
+		return true;
+	});
+}
+/**
+* Get photo info if needed, and throw errors if it's not a photo
+*/
+async function resolvePhotoIdentifier(identifier) {
+	if (isPhotoInfo(identifier)) return identifier;
+	const aphexPhotoInfoResult = await aphexPhotoInfo(identifier);
+	if (aphexPhotoInfoResult.length === 0) throw new Error(`No photo asset found for identifier "${identifier}"`);
+	if (aphexPhotoInfoResult.length > 1) throw new Error(`Multiple photo assets found for identifier "${identifier} — is it an album?"`);
+	return aphexPhotoInfoResult[0];
+}
+//#endregion
+//#region src/utilities/defaults.ts
+const mergeDefaultsInternal = createDefu((object, key, value) => {
+	if (Array.isArray(object[key]) && Array.isArray(value)) {
+		const merged = [...new Set([...object[key], ...value])];
+		Object.assign(object, { [key]: merged });
+		return true;
+	}
+	return false;
+});
+/**
+* Merge, treating arrays like sets
+*/
+function mergeDefaults(options, defaults) {
+	if (options === void 0) return defaults;
+	return mergeDefaultsInternal(options, defaults);
+}
+//#endregion
+//#region src/utilities/image/mime.ts
+mimes.arw = "image/arw";
+mimes.cr2 = "image/cr2";
+mimes.cr3 = "image/cr3";
+mimes.crw = "image/crw";
+mimes.dng = "image/dng";
+mimes.nef = "image/nef";
+mimes.pef = "image/pef";
+mimes.psb = "image/psb";
+mimes.psd = "image/psd";
+mimes.psd = "image/psd";
+mimes.raw = "image/raw";
+mimes.tga = "image/tga";
+const IMAGE_MIME_TYPES = [
+	"arw",
+	"avif",
+	"bmp",
+	"cr2",
+	"cr3",
+	"crw",
+	"tga",
+	"dng",
+	"gif",
+	"heic",
+	"heif",
+	"jpeg",
+	"nef",
+	"pef",
+	"png",
+	"psd",
+	"svg+xml",
+	"tiff",
+	"webp"
+];
+/**
+* Look up the MIME type of an image
+*
+* Note overloads
+*/
+function lookupImageMimeType(imagePath, validate = false) {
+	const mime = lookup(imagePath);
+	const shouldValidate = Array.isArray(validate) || validate;
+	if (mime === void 0) {
+		if (shouldValidate) throw new Error(`No known image MIME type for ${imagePath}`);
+		return;
+	}
+	const matchedMimeTypes = (Array.isArray(validate) ? validate : IMAGE_MIME_TYPES).find((type) => `image/${type}` === mime);
+	if (shouldValidate && matchedMimeTypes === void 0) throw new Error(`Invalid image MIME type: ${mime} for ${imagePath}`);
+	return matchedMimeTypes;
+}
+//#endregion
+//#region src/utilities/image/color.ts
+const SIPS_PROFILE_REGEX = /profile: (.+)/;
+/**
+* Get the color profile of an image
+* https://github.com/saucecontrol/Compact-ICC-Profiles?tab=readme-ov-file
+*/
+async function getColorProfile(imagePath) {
+	const { stdout } = await execa("sips", [
+		"-g",
+		"profile",
+		imagePath
+	]);
+	const rawResult = SIPS_PROFILE_REGEX.exec(stdout)?.[1]?.trim();
+	const sipsProfile = rawResult === "<nil>" ? void 0 : rawResult;
+	const { ProfileDescription: rawExiftoolProfile } = await getExiftool().read(imagePath);
+	const exiftoolProfile = typeof rawExiftoolProfile === "string" ? rawExiftoolProfile.trim() : rawExiftoolProfile;
+	if (sipsProfile !== void 0 && exiftoolProfile !== void 0 && sipsProfile !== exiftoolProfile) log.error(`Conflicting color profiles: sips: "${sipsProfile}", exiftool: "${exiftoolProfile}" in image "${imagePath}"`);
+	const profile = sipsProfile ?? exiftoolProfile;
+	switch (profile) {
+		case "Adobe RGB (1998)": return "Adobe RGB (1998)";
+		case "Apple Wide Color Sharing Profile": return "Apple Wide Color Sharing Profile";
+		case "Display P3": return "Display P3";
+		case "ProPhoto RGB": return "ProPhoto RGB";
+		case "sRGB IEC61966-2.1": return "sRGB IEC61966-2.1";
+		case void 0: return "None";
+		default:
+			log.warn(`Unsupported color profile "${profile}"  in image "${imagePath}"`);
+			return "Unsupported";
+	}
+}
+/**
+* Get the path to a color profile
+*/
+function getPathToColorProfile(profile) {
+	const basePath = path.join(getPackageAssetsPath(import.meta), "profiles");
+	switch (profile) {
+		case "Adobe RGB (1998)": return path.join(basePath, "AdobeRGB1998.icc");
+		case "Display P3": return path.join(basePath, "Display P3.icc");
+		case "ProPhoto RGB": return path.join(basePath, "ProPhoto.icm");
+		case "sRGB IEC61966-2.1": return path.join(basePath, "sRGB Profile.icc");
+		default: throw new Error(`Unsupported profile: ${profile}`);
+	}
+}
+/**
+* Convert the color profile of an image
+*/
+async function convertColorProfile(imagePath, profile) {
+	const currentProfile = await getColorProfile(imagePath);
+	if (profile === "Unsupported") throw new Error(`Can't assign unsupported profile`);
+	if (currentProfile === profile) return;
+	if (currentProfile === "None") {
+		await getExiftool().write(imagePath, {}, { writeArgs: ["-ICC_Profile=", "-overwrite_original_in_place"] });
+		return;
+	}
+	const mime = lookupImageMimeType(imagePath, true);
+	if ([
+		"png",
+		"psd",
+		"tif"
+	].includes(mime)) {
+		log.debug(`Converting ${path.basename(imagePath)} from ${currentProfile} to ${profile}`);
+		await execa("sips", [
+			"--matchTo",
+			getPathToColorProfile(profile),
+			imagePath
+		]);
+	} else if ([
+		"avif",
+		"gif",
+		"heic",
+		"jpeg",
+		"webp"
+	].includes(mime)) throw new Error(`Color profile conversion would be destructive for image ${path.basename(imagePath)}, aborting`);
+	else throw new Error(`Unsupported image format: ${mime}`);
+}
+/**
+* Assign a color profile to an image
+*/
+async function assignColorProfile(imagePath, profile) {
+	if (profile === "Unsupported") throw new Error(`Can't assign unsupported profile`);
+	if (profile === await getColorProfile(imagePath)) return;
+	if (profile === "None") {
+		await getExiftool().write(imagePath, {}, { writeArgs: ["-ICC_Profile=", "-overwrite_original_in_place"] });
+		return;
+	}
+	const mime = lookupImageMimeType(imagePath, true);
+	if (mime === "avif") log.warn(`Unsupported mime type for color profile assignment: ${mime}, skipping`);
+	else await getExiftool().write(imagePath, {}, { writeArgs: [`-ICC_Profile<=${getPathToColorProfile(profile)}`, "-overwrite_original_in_place"] });
+}
+/**
+* Check if an image needs color conversion
+*/
+async function needsColorConversion(imagePath, preserveColorProfiles = [
+	"ProPhoto RGB",
+	"Display P3",
+	"sRGB IEC61966-2.1",
+	"Adobe RGB (1998)"
+]) {
+	const profile = await getColorProfile(imagePath);
+	return !["None", ...preserveColorProfiles].includes(profile);
+}
+/**
+* Normalize the color profile of an image
+*/
+async function normalizeColorProfile(imagePath, preserveColorProfiles = [
+	"ProPhoto RGB",
+	"Display P3",
+	"sRGB IEC61966-2.1",
+	"Adobe RGB (1998)"
+], defaultColorProfile = "sRGB IEC61966-2.1") {
+	const profile = await getColorProfile(imagePath);
+	if (preserveColorProfiles.includes(profile)) return "no-action";
+	if (profile === "None") {
+		await assignColorProfile(imagePath, defaultColorProfile);
+		return "assigned";
+	}
+	await convertColorProfile(imagePath, defaultColorProfile);
+	return "converted";
+}
+//#endregion
+//#region src/utilities/image/tags.ts
+const VALID_LABELS = [
+	"animation",
+	"diagram",
+	"illustration",
+	"image",
+	"photo",
+	"render",
+	"screenshot",
+	"video"
+];
+function isValidLabel(value) {
+	return VALID_LABELS.includes(value);
+}
+/**
+* Strip all metadata from an image
+*/
+async function stripTags(imagePath) {
+	if (lookupImageMimeType(imagePath, true) === "avif") await getExiftool().write(imagePath, {}, { writeArgs: [
+		"-all=",
+		"--icc_profile:all",
+		"-overwrite_original_in_place"
+	] });
+	else await getExiftool().write(imagePath, {}, { writeArgs: ["-all=", "-overwrite_original_in_place"] });
+}
+/**
+* Validate that an image has the required tags
+*/
+async function validateTags(imagePathOrTags, andKeys, orKeys, logWarnings = true) {
+	const result = {
+		issues: [],
+		valid: true
+	};
+	const tags = typeof imagePathOrTags === "string" ? await getTags(imagePathOrTags) : imagePathOrTags;
+	if (orKeys === void 0 && andKeys === void 0) {
+		const keysUnseen = [
+			"creator",
+			"credit",
+			"label",
+			"preservedFileName"
+		].filter((key) => tags[key] === void 0);
+		if (keysUnseen.length > 0) {
+			result.issues.push(`Tags are missing keys: ${keysUnseen.join(", ")}`);
+			if (logWarnings) log.warn(result.issues.at(-1));
+			result.valid = false;
+		}
+	}
+	if (orKeys !== void 0 && orKeys.length > 0) {
+		if (orKeys.filter((key) => tags[key] !== void 0).length === 0) {
+			result.issues.push(`Tags should have at least one of the keys: ${orKeys.join(", ")}`);
+			if (logWarnings) log.warn(result.issues.at(-1));
+			result.valid = false;
+		}
+	}
+	if (andKeys !== void 0 && andKeys.length > 0) {
+		const andKeysUnseen = andKeys.filter((key) => tags[key] === void 0);
+		if (andKeysUnseen.length > 0) {
+			result.issues.push(`Tags are missing the keys: ${andKeysUnseen.join(", ")}`);
+			if (logWarnings) log.warn(result.issues.at(-1));
+			result.valid = false;
+		}
+	}
+	if (tags.label !== void 0 && !VALID_LABELS.includes(tags.label)) {
+		result.issues.push(`Tag value for 'label' is invalid: ${tags.label}`);
+		if (logWarnings) log.warn(result.issues.at(-1));
+		result.valid = false;
+	}
+	return result;
+}
+/**
+* Get the tags from an image
+*/
+async function getTags(imagePath) {
+	const { Creator: creator, Credit: credit, Description: description, Label: label, PreservedFileName: preservedFileName, UserComment: userComment } = (await getExiftool().readRaw(imagePath, { readArgs: ["-g", "-xmp:all"] })).XMP ?? {};
+	return {
+		aphexMetadata: parseUserComment(userComment),
+		creator: creator === void 0 ? void 0 : typeof creator === "string" ? creator : creator[0],
+		credit,
+		description,
+		label: label !== void 0 && isValidLabel(label) ? label : void 0,
+		preservedFileName
+	};
+}
+function dateReviver(key, value) {
+	if ((key === "dateCreated" || key === "dateModified" || key === "dateStart" || key === "dateEnd") && typeof value === "string") return value ? new Date(value) : void 0;
+	return value;
+}
+function isAphexMetadata(value) {
+	if (typeof value !== "object" || value === null) return false;
+	const maybeObject = value;
+	return typeof maybeObject.exportOptions === "object" && maybeObject.exportOptions !== null && typeof maybeObject.photoInfo === "object" && maybeObject.photoInfo !== null;
+}
+function parseUserComment(userComment) {
+	if (userComment === void 0) return;
+	try {
+		const parsed = JSON.parse(userComment, dateReviver);
+		if (!isAphexMetadata(parsed)) {
+			log.warn(`UserComment JSON does not match AphexMetadata shape: ${userComment}`);
+			return;
+		}
+		return parsed;
+	} catch (error) {
+		log.withError(error).error(`Error parsing UserComment JSON: ${userComment}`);
+		return;
+	}
+}
+/**
+* Set the tags on an image
+*/
+async function setTags(imagePath, imageTags) {
+	const { aphexMetadata, creator, credit, description, label, preservedFileName } = imageTags;
+	const userComment = aphexMetadata ? JSON.stringify(aphexMetadata) : void 0;
+	const tags = {
+		..."creator" in imageTags ? { "XMP:Creator": creator ?? "" } : {},
+		..."description" in imageTags ? { "XMP:Description": description ?? "" } : {},
+		..."credit" in imageTags ? { "XMP:Credit": credit ?? "" } : {},
+		..."label" in imageTags ? { "XMP:Label": label ?? "" } : {},
+		..."preservedFileName" in imageTags ? { "XMP:PreservedFileName": preservedFileName ?? "" } : {},
+		..."aphexMetadata" in imageTags ? { "XMP:UserComment": userComment ?? "" } : {}
+	};
+	await getExiftool().write(imagePath, tags, { writeArgs: ["-overwrite_original_in_place"] });
+}
+/**
+* Clone tags from one image to another
+*/
+async function cloneTags(sourceImagePath, destinationImagePath, includeKeys, force = false) {
+	const sourceTags = await getTags(sourceImagePath);
+	const destinationTags = await getTags(destinationImagePath);
+	const keys = includeKeys ?? [
+		"creator",
+		"credit",
+		"description",
+		"label",
+		"preservedFileName",
+		"aphexMetadata"
+	];
+	let tagsToAssign = {};
+	for (const key of keys) {
+		const sourceValue = key in sourceTags ? sourceTags[key] : void 0;
+		if (sourceValue !== (key in destinationTags ? destinationTags[key] : void 0) || force) tagsToAssign = {
+			...tagsToAssign,
+			[key]: sourceValue
+		};
+	}
+	if (Object.keys(tagsToAssign).length > 0) await setTags(destinationImagePath, tagsToAssign);
+	return Object.keys(tagsToAssign);
+}
+//#endregion
+//#region src/utilities/image/image.ts
+/**
+* Get all available information about an image
+*/
+async function getImageInfo(imagePath) {
+	return {
+		alpha: await hasAlpha(imagePath),
+		colorProfile: await getColorProfile(imagePath),
+		dimensionsPixels: await getImageDimensions(imagePath),
+		mime: lookupImageMimeType(imagePath, true),
+		path: imagePath,
+		sizeBytes: await getSizeBytes(imagePath),
+		tags: await getTags(imagePath)
+	};
+}
+/**
+* Get the dimensions of an image
+*/
+async function getImageDimensions(imagePath) {
+	const { width, height } = await imageSizeFromFile(imagePath);
+	return {
+		width,
+		height
+	};
+}
+/**
+* Check if an image has an alpha channel
+*/
+async function hasAlpha(imagePath) {
+	const mime = lookupImageMimeType(imagePath, true);
+	if (mime === "jpeg") return false;
+	if (mime !== "psd" && mime !== "tiff") {
+		const { stdout: channelOutput } = await execa("identify", [
+			"-format",
+			"%[channels]",
+			imagePath
+		]);
+		if (!channelOutput.includes("rgba")) return false;
+	}
+	try {
+		const { stdout } = await execa("magick", [
+			imagePath,
+			"-background",
+			"transparent",
+			"-flatten",
+			"-channel",
+			"A",
+			"-separate",
+			"+channel",
+			"-format",
+			"%[fx:minima]",
+			"info:"
+		]);
+		return Number(stdout) < 1;
+	} catch (error) {
+		throw new Error(`Error checking file: ${String(error)}`);
+	}
+}
+//#endregion
+//#region src/pipeline/engines/applescript.ts
+const UUID_SUFFIX_PHOTO = "/L0/001";
+function escapeForAppleScript(text) {
+	return text.replaceAll("\\", "\\\\").replaceAll("\"", "\\\"");
+}
+/**
+* Export a photo via AppleScript using the Photos app's scripting dictionary
+* @param photoUuid - UUID of the photo to export
+* @param forceOriginal - Whether to force export of original version
+* @returns Promise<string> - Path to the exported file
+*/
+async function exportViaAppleScript(photoUuid, forceOriginal = false) {
+	const tempDirectory = await getTempDirectory("engine", "applescript");
+	const exportFlag = forceOriginal ? "with originals" : "without originals";
+	const appleScript = `
+    tell application "Photos"
+      -- Find the media item by UUID
+      set targetPhoto to (first media item whose id is "${escapeForAppleScript(`${photoUuid}${UUID_SUFFIX_PHOTO}`)}")
+
+      -- Export the photo to temp directory
+      export {targetPhoto} to POSIX file "${escapeForAppleScript(tempDirectory)}" ${exportFlag}
+
+      -- Get the exported file name
+      set photoFilename to filename of targetPhoto
+
+      -- Return the filename for path construction
+      return photoFilename
+    end tell
+  `;
+	try {
+		const { stdout } = await execa("osascript", ["-e", appleScript]);
+		const exportedFileName = stdout.trim();
+		return path.join(tempDirectory, exportedFileName);
+	} catch (error) {
+		const errorMessage = error instanceof Error ? error.message : String(error);
+		throw new Error(`Failed to export photo via AppleScript: ${errorMessage}`);
+	}
+}
+//#endregion
+//#region src/pipeline/engines/applescript-gui.ts
+/** Apple's defaults, but these are overridden by Aphex by default */
+const defaultExportViaAppleScriptGuiOptions = {
+	colorProfile: "Most Compatible",
+	fileName: "Use File Name",
+	includeLocation: true,
+	includeMetadata: true,
+	jpegQuality: "High",
+	maxSizeType: "Dimension",
+	maxSizeValue: 2048,
+	photoKind: "JPEG",
+	photoSize: "Large",
+	sequentialPrefix: "",
+	subfolderFormat: "None",
+	tiffBitDepth: 8
+};
+/**
+* Export a photo via the Photos.app GUI to a temporary directory
+* Clean up and move the file as needed afterwards
+*/
+async function exportViaAppleScriptGui(uuid, options) {
+	const tempDirectory = await getTempDirectory("engine", "applescript-gui");
+	const { colorProfile, fileName, includeLocation, includeMetadata, jpegQuality, maxSizeType, maxSizeValue, photoKind, photoSize, sequentialPrefix, subfolderFormat, tiffBitDepth } = mergeDefaults(options, defaultExportViaAppleScriptGuiOptions);
+	const { failed, stderr } = await execa("osascript", [
+		path.join(getPackageAssetsPath(import.meta), "applescript-gui.applescript"),
+		uuid,
+		tempDirectory,
+		photoKind,
+		jpegQuality,
+		tiffBitDepth.toString(),
+		colorProfile,
+		photoSize,
+		maxSizeType,
+		maxSizeValue.toString(),
+		includeMetadata.toString(),
+		includeLocation.toString(),
+		fileName,
+		sequentialPrefix,
+		subfolderFormat
+	]);
+	if (failed) throw new Error(`Error exporting album "${uuid}": ${stderr}`);
+	const results = stderr.split("\n").filter((line) => line.trim() !== "");
+	if (results.length === 0) throw new Error(`No photos exported for album "${uuid}"`);
+	if (typeof results[0] !== "string") throw new TypeError(`Unexpected export results for album "${uuid}": ${JSON.stringify(results)}`);
+	return results;
+}
+//#endregion
+//#region src/pipeline/engines/file-system.ts
+/**
+* Export a photo via direct file system copy of the original or edited file to a temporary directory
+* Clean up and move the file as needed afterwards
+*/
+async function exportViaFileSystem(photoUuid, forceOriginal = false) {
+	const [{ edited, original }] = isPhotoInfo(photoUuid) ? [photoUuid] : await aphexPhotoInfo(photoUuid);
+	const tempDirectory = await getTempDirectory("engine", "file-system");
+	if (forceOriginal || edited === void 0) {
+		const destinationPath = path.join(tempDirectory, original.fileName);
+		await fse.copy(original.filePath, destinationPath, { overwrite: true });
+		return destinationPath;
+	}
+	const destinationPath = path.join(tempDirectory, edited.fileName);
+	await fse.copy(edited.filePath, destinationPath, { overwrite: true });
+	return destinationPath;
+}
+//#endregion
+//#region src/pipeline/engines/swift-photokit.ts
+/**
+* Export a photo via aphex-swift command line tool using PhotoKit
+*/
+async function exportViaSwiftPhotoKit(photoUuid) {
+	const [result] = await aphexExport(photoUuid, await getTempDirectory("engine", "swift-photokit"));
+	return result;
+}
+//#endregion
+//#region src/pipeline/image-export.ts
+const defaultExportApplePhotoOptions = {
+	appleScriptGuiOptions: {
+		colorProfile: "sRGB",
+		fileName: "Use File Name",
+		includeLocation: false,
+		includeMetadata: false,
+		jpegQuality: "Maximum",
+		maxSizeType: "Dimension",
+		maxSizeValue: Number.MAX_SAFE_INTEGER,
+		photoKind: "PNG",
+		photoSize: "Full Size",
+		sequentialPrefix: "",
+		subfolderFormat: "None",
+		tiffBitDepth: 8
+	},
+	engineEdited: "photos-gui",
+	engineEditedAlpha: "swift-photokit",
+	engineOriginal: {
+		arw: "photos-gui",
+		avif: "swift-photokit",
+		cr2: "photos-gui",
+		cr3: "photos-gui",
+		crw: "photos-gui",
+		dng: "photos-gui",
+		gif: "swift-photokit",
+		heic: "swift-photokit",
+		heif: "swift-photokit",
+		jpeg: "swift-photokit",
+		nef: "photos-gui",
+		pef: "photos-gui",
+		png: "photos-gui",
+		psd: "photos-gui",
+		tiff: "photos-gui",
+		webp: "swift-photokit"
+	},
+	engineOriginalAlpha: "swift-photokit",
+	fileNameAppendUuidFragment: false,
+	fileNameNormalizeExtensions: true,
+	fileNamePrecedence: [
+		"title",
+		"fileName",
+		"uuid"
+	],
+	fileNameSluggify: true
+};
+/**
+* Export a batch of photos
+*/
+async function exportApplePhotos(identifiers, destinationDirectory, options) {
+	const resolvedOptions = mergeDefaults(options, defaultExportApplePhotoOptions);
+	const photoInfos = await resolveIdentifiers(identifiers);
+	const exportedPhotos = [];
+	for (const photoInfo of photoInfos) {
+		const engine = await getEngineForPhoto(photoInfo, resolvedOptions);
+		const exportedPhoto = {
+			exportEngine: engine,
+			exportOptions: resolvedOptions,
+			path: "",
+			photoInfo
+		};
+		switch (engine) {
+			case "applescript":
+				exportedPhoto.path = await exportViaAppleScript(photoInfo.uuid);
+				break;
+			case "file-system":
+				exportedPhoto.path = await exportViaFileSystem(photoInfo);
+				break;
+			case "photos-gui": {
+				const [exportedPath] = await exportViaAppleScriptGui(photoInfo.uuid, resolvedOptions.appleScriptGuiOptions);
+				exportedPhoto.path = exportedPath;
+				break;
+			}
+			case "swift-photokit":
+				exportedPhoto.path = await exportViaSwiftPhotoKit(photoInfo.uuid);
+				break;
+		}
+		const resolvedDestinationDirectory = await ensureDirectoryExists(destinationDirectory);
+		const normalizedDestinationPath = getImagePathWithFileName(photoInfo, path.join(resolvedDestinationDirectory, path.basename(exportedPhoto.path)), resolvedOptions.fileNameSluggify, resolvedOptions.fileNameAppendUuidFragment, resolvedOptions.fileNameNormalizeExtensions, resolvedOptions.fileNamePrecedence);
+		await fse.rename(exportedPhoto.path, normalizedDestinationPath);
+		const tempDirectory = path.dirname(exportedPhoto.path);
+		await fse.rm(tempDirectory, {
+			force: true,
+			recursive: true
+		});
+		exportedPhoto.path = normalizedDestinationPath;
+		exportedPhotos.push(exportedPhoto);
+	}
+	return exportedPhotos;
+}
+/** Also normalizes */
+function getImagePathWithFileName(photoInfo, filePath, sluggify = true, fileNameAppendUuidFragment = false, normalizeExtensions = true, namingStrategyPrecedence = [
+	"title",
+	"fileName",
+	"uuid"
+]) {
+	const normalizedPath = normalizeExtensions ? normalizeExtension(filePath) : filePath;
+	const basePath = path.dirname(normalizedPath);
+	const extension = path.extname(normalizedPath);
+	for (const option of namingStrategyPrecedence) switch (option) {
+		case "fileName": {
+			const nameWithoutExtension = path.basename(photoInfo.original.fileName, path.extname(photoInfo.original.fileName));
+			const uuidFragment = fileNameAppendUuidFragment ? `-${photoInfo.uuid.slice(-8)}` : "";
+			const processedName = sluggify ? slug(`${nameWithoutExtension}${uuidFragment}`) : `${nameWithoutExtension}${uuidFragment}`;
+			return path.join(basePath, `${processedName}${extension}`);
+		}
+		case "title":
+			if (isNonEmptyStringAndNotWhitespace(photoInfo.title)) {
+				const title = sluggify ? slug(photoInfo.title) : photoInfo.title;
+				const uuidFragment = fileNameAppendUuidFragment ? `-${photoInfo.uuid.slice(-8)}` : "";
+				const processedTitle = sluggify ? slug(`${title}${uuidFragment}`) : `${title}${uuidFragment}`;
+				return path.join(basePath, `${processedTitle}${extension}`);
+			}
+			break;
+		case "uuid": {
+			const processedUuid = sluggify ? slug(photoInfo.uuid) : photoInfo.uuid;
+			return path.join(basePath, `${processedUuid}${extension}`);
+		}
+	}
+	throw new Error("No valid filename option found, can't name image");
+}
+async function getEngineForPhoto(photoInfo, options) {
+	const { engineEdited, engineEditedAlpha, engineOriginal, engineOriginalAlpha } = mergeDefaults(options, defaultExportApplePhotoOptions);
+	if (!photoInfo.edited) {
+		const alpha = await hasAlpha(photoInfo.original.filePath);
+		const type = lookupImageMimeType(photoInfo.original.filePath, true);
+		const engine = alpha ? typeof engineOriginalAlpha === "string" ? engineOriginalAlpha : engineOriginalAlpha[type] : typeof engineOriginal === "string" ? engineOriginal : engineOriginal[type];
+		if (engine === void 0) throw new Error(`No export engine found for original photo "${photoInfo.title}" of type "${type}"${alpha ? " with alpha channel" : ""}`);
+		return engine;
+	}
+	const alpha = await hasAlpha(photoInfo.edited.filePath);
+	if (alpha) log.warn(`Edited photo "${photoInfo.title}" has true transparency, it probably won't export correctly. Only un-edited files preserve transparency on export.`);
+	const type = lookupImageMimeType(photoInfo.edited.filePath, true);
+	const engine = alpha ? typeof engineEditedAlpha === "string" ? engineEditedAlpha : engineEditedAlpha[type] : typeof engineEdited === "string" ? engineEdited : engineEdited[type];
+	if (engine === void 0) throw new Error(`No export engine found for edited photo "${photoInfo.title}" of type "${type}"${alpha ? " with alpha channel" : ""}`);
+	return engine;
+}
+/**
+* Export a single album to a folder
+* Optionally sync the output directory with the album, deleting any images that are no longer in the album
+* Optionally audit the album for duplicate titles
+* Does NOT further process the images
+*/
+//#endregion
+//#region src/pipeline/image-metadata.ts
+const defaultManageMetadataOptions = {
+	syncToEdited: true,
+	syncToTarget: true,
+	tagsToSync: [
+		"label",
+		"preservedFileName",
+		"creator",
+		"credit",
+		"description"
+	],
+	validate: true,
+	writeAphexMetadata: true
+};
+/**
+* Manage metadata for a batch of photos
+*/
+async function manageMetadataBatch(identifiers, targetFilePaths, options, exportOptions) {
+	const photoInfos = await resolveIdentifiers(identifiers);
+	if (photoInfos.length !== targetFilePaths.length) throw new Error("Photo infos and target files length mismatch");
+	return Promise.all(photoInfos.map(async (photoInfo, index) => manageMetadata(photoInfo, targetFilePaths[index], options, exportOptions)));
+}
+/**
+* Manage metadata...
+*/
+async function manageMetadata(identifier, targetFilePath, options, exportOptions) {
+	const resolvedOptions = mergeDefaults(options, defaultManageMetadataOptions);
+	const photoInfo = await resolvePhotoIdentifier(identifier);
+	let tagsToTarget;
+	if (resolvedOptions.syncToTarget) tagsToTarget = await cloneTags(photoInfo.original.filePath, targetFilePath, resolvedOptions.tagsToSync);
+	let tagsToEdited;
+	if (photoInfo.edited && resolvedOptions.syncToEdited) tagsToEdited = await cloneTags(photoInfo.original.filePath, photoInfo.edited.filePath, resolvedOptions.tagsToSync);
+	if (exportOptions !== void 0 && resolvedOptions.writeAphexMetadata) await setTags(targetFilePath, { aphexMetadata: {
+		exportOptions,
+		photoInfo
+	} });
+	let validationResult;
+	if (resolvedOptions.validate) validationResult = await validateTags(targetFilePath);
+	return {
+		photoInfo,
+		tagsToEdited,
+		tagsToTarget,
+		validationResult
+	};
+}
+//#endregion
+//#region src/utilities/image/convert.ts
+/**
+* Optimize a PNG image
+*/
+async function optimizePng(imagePath, destinationDirectory) {
+	lookupImageMimeType(imagePath, ["png"]);
+	const destinationImagePath = path.join(destinationDirectory, path.basename(imagePath));
+	await execa("oxipng", [
+		"--scale16",
+		"--alpha",
+		"--preserve",
+		"--nc",
+		"--out",
+		destinationImagePath,
+		imagePath
+	]);
+	return destinationImagePath;
+}
+/**
+* Resize a PNG image to fit within a maximum width and height
+* Copies the image unchanged if it already fits within the target size
+* @returns The destination image path
+*/
+async function resizePngToFit(imagePath, destinationDirectory, maxWidth, maxHeight) {
+	lookupImageMimeType(imagePath, ["png"]);
+	if (maxWidth <= 0 || maxHeight <= 0) throw new Error(`Invalid target size: ${maxWidth} x ${maxHeight}`);
+	const { width, height } = await getImageDimensions(imagePath);
+	const destinationImagePath = path.join(destinationDirectory, path.basename(imagePath));
+	if (height <= maxHeight && width <= maxWidth) await fse.copy(imagePath, destinationImagePath);
+	else await execa("convert", [
+		imagePath,
+		"-resize",
+		`${maxWidth}x${maxHeight}`,
+		"-filter",
+		"Lanczos",
+		destinationImagePath
+	]);
+	return destinationImagePath;
+}
+/**
+* Resize a PNG image to fit within a maximum width and height
+*/
+async function convertToJpeg(sourceImagePath, destinationDirectory, quality, force = false, engine = "mozjpeg") {
+	const mime = lookupImageMimeType(sourceImagePath, [
+		"bmp",
+		"jpeg",
+		"png",
+		"tiff",
+		"webp"
+	]);
+	const destinationImagePath = path.join(destinationDirectory, path.basename(sourceImagePath, path.extname(sourceImagePath)) + ".jpeg");
+	if (!force && mime === "jpeg") await fse.copy(sourceImagePath, destinationImagePath);
+	else {
+		const jpegQuality = quality === "lossless" ? "lossless" : Math.round(quality * 100);
+		switch (engine) {
+			case "guetzli":
+				if (jpegQuality === "lossless") throw new Error("Lossless JPEG conversion not supported with guetzli");
+				await execa("guetzli", [
+					"--quality",
+					jpegQuality.toString(),
+					sourceImagePath,
+					destinationImagePath
+				]);
+				break;
+			case "mozjpeg": {
+				const tgaTempDirectory = await fse.mkdtemp(path.join(os.tmpdir(), `com.kitschpatrol.aphex.${getSlugFilename(sourceImagePath)}.${engine}.`));
+				const tgaImagePath = await convertToTga(sourceImagePath, tgaTempDirectory);
+				await (jpegQuality === "lossless" ? execa("cjpeg", [
+					"--lossless",
+					"-optimize",
+					"-progressive",
+					"-outfile",
+					destinationImagePath,
+					tgaImagePath
+				]) : execa("cjpeg", [
+					"-quality",
+					jpegQuality.toString(),
+					"-optimize",
+					"-progressive",
+					"-outfile",
+					destinationImagePath,
+					tgaImagePath
+				]));
+				await fse.rm(tgaTempDirectory, { recursive: true });
+				break;
+			}
+			case "sips":
+				if (jpegQuality === "lossless") throw new Error("Lossless JPEG conversion not supported with sips");
+				await execa("sips", [
+					"-s",
+					"format",
+					"jpeg",
+					"-s",
+					"formatOptions",
+					jpegQuality.toString(),
+					sourceImagePath,
+					"--out",
+					destinationImagePath
+				]);
+				break;
+		}
+	}
+	return destinationImagePath;
+}
+/**
+* Convert an image to a WebP
+*/
+async function convertToWebp(sourceImagePath, destinationDirectory, quality, force = false) {
+	const mime = lookupImageMimeType(sourceImagePath, true);
+	const destinationImagePath = path.join(destinationDirectory, path.basename(sourceImagePath, path.extname(sourceImagePath)) + ".webp");
+	if (!force && mime === "webp") await fse.copy(sourceImagePath, destinationImagePath);
+	else {
+		const webpQuality = typeof quality === "number" ? Math.round(quality * 100) : quality;
+		await execa("cwebp", [
+			...quality === "lossless" ? ["-lossless"] : quality === "near-lossless" ? ["-near_lossless", "100"] : ["-q", String(webpQuality)],
+			"-mt",
+			"-metadata",
+			"all",
+			sourceImagePath,
+			"-o",
+			destinationImagePath
+		]);
+	}
+	return destinationImagePath;
+}
+/**
+* Convert an image to a PNG
+* Supports width / height to help quality comparison tools match target sizes in one step
+*/
+async function convertToPng(sourceImagePath, destinationDirectory, force = false, width, height) {
+	const mime = lookupImageMimeType(sourceImagePath, true);
+	const destinationImagePath = path.join(destinationDirectory, path.basename(sourceImagePath, path.extname(sourceImagePath)) + ".png");
+	const needsResize = width !== void 0 && height !== void 0;
+	if (!force && mime === "png" && !needsResize) await fse.copyFile(sourceImagePath, destinationImagePath);
+	else {
+		const resizeArgs = needsResize ? [
+			"--resampleHeightWidth",
+			height.toString(),
+			width.toString()
+		] : [];
+		const restoreColorProfile = mime === "psd" ? await getColorProfile(sourceImagePath) : void 0;
+		await execa("sips", [
+			...resizeArgs,
+			"--setProperty",
+			"format",
+			"png",
+			...restoreColorProfile && restoreColorProfile !== "None" ? [
+				"--setProperty",
+				"profile",
+				getPathToColorProfile(restoreColorProfile)
+			] : [],
+			sourceImagePath,
+			"--out",
+			destinationImagePath
+		]);
+	}
+	return destinationImagePath;
+}
+/**
+* Convert an image to a TGA
+* Only viable input to mozjpeg is TGA, BMP, and some other esoteric stuff...
+* BMP emitted by sips is too modern for cjpeg, so we need to convert to TGA instead
+*/
+async function convertToTga(sourceImagePath, destinationDirectory, force = false) {
+	const mime = lookupImageMimeType(sourceImagePath, [
+		"tga",
+		"png",
+		"tiff",
+		"psd",
+		"jpeg",
+		"heic",
+		"avif"
+	]);
+	const destinationImagePath = path.join(destinationDirectory, path.basename(sourceImagePath, path.extname(sourceImagePath)) + ".bmp");
+	await (!force && mime === "tga" ? fse.copyFile(sourceImagePath, destinationImagePath) : execa("sips", [
+		"--setProperty",
+		"format",
+		"tga",
+		sourceImagePath,
+		"--out",
+		destinationImagePath
+	]));
+	return destinationImagePath;
+}
+/**
+* Convert an image to an AVIF
+*/
+async function convertToAvif(sourceImagePath, destinationDirectory, quality, force = false) {
+	const mime = lookupImageMimeType(sourceImagePath, true);
+	const destinationImagePath = path.join(destinationDirectory, path.basename(sourceImagePath, path.extname(sourceImagePath)) + ".avif");
+	if (!force && mime === "avif") await fse.copy(sourceImagePath, destinationImagePath);
+	else {
+		const qualityArgs = quality === "lossless" ? ["--lossless"] : typeof quality === "number" ? ["-q", Math.round(quality * 63).toString()] : [
+			"-qcolor",
+			quality.color.toString(),
+			"--qalpha",
+			quality.alpha.toString()
+		];
+		const profile = await getColorProfile(sourceImagePath);
+		await execa("avifenc", [
+			...qualityArgs,
+			"--icc",
+			profile === "None" ? getPathToColorProfile("sRGB IEC61966-2.1") : getPathToColorProfile(profile),
+			"--speed",
+			"default",
+			sourceImagePath,
+			destinationImagePath
+		]);
+	}
+	return destinationImagePath;
+}
+/**
+* Compress an image to a target size
+*/
+async function compressImage(sourceImagePath, destinationDirectory, options) {
+	const { forceCompression, losslessFormat, lossyFormat, lossyQuality, maxFileSizeBytes, nearLosslessFormat } = options;
+	if (losslessFormat === "none" && nearLosslessFormat === "none" && lossyFormat === "none") throw new Error("At least one compression format must be enabled");
+	const initialSize = await getSizeBytes(sourceImagePath);
+	if (!forceCompression && initialSize <= maxFileSizeBytes) {
+		const destinationImagePath = path.join(destinationDirectory, path.basename(sourceImagePath));
+		await fse.copyFile(sourceImagePath, destinationImagePath);
+		return {
+			compression: "none",
+			path: destinationImagePath
+		};
+	}
+	let workingImagePath;
+	const tempDirectory = await fse.mkdtemp(path.join(os.tmpdir(), `com.kitschpatrol.aphex.${getSlugFilename(sourceImagePath)}.compress.`));
+	switch (losslessFormat) {
+		case "avif":
+			workingImagePath = await convertToAvif(sourceImagePath, tempDirectory, "lossless");
+			break;
+		case "none":
+			workingImagePath = sourceImagePath;
+			break;
+		case "png":
+			workingImagePath = lookupImageMimeType(sourceImagePath) === "png" ? sourceImagePath : await convertToPng(sourceImagePath, tempDirectory);
+			workingImagePath = await optimizePng(workingImagePath, tempDirectory);
+			break;
+		case "webp":
+			workingImagePath = await convertToWebp(sourceImagePath, tempDirectory, "lossless");
+			break;
+	}
+	if (await getSizeBytes(workingImagePath) <= maxFileSizeBytes) {
+		const destinationImagePath = path.join(destinationDirectory, path.basename(workingImagePath));
+		await fse.copyFile(workingImagePath, destinationImagePath);
+		await fse.rm(tempDirectory, {
+			force: true,
+			recursive: true
+		});
+		return {
+			compression: "lossless",
+			path: destinationImagePath
+		};
+	}
+	if (workingImagePath !== sourceImagePath) await fse.rm(workingImagePath);
+	switch (nearLosslessFormat) {
+		case "none":
+			workingImagePath = sourceImagePath;
+			break;
+		case "webp":
+			workingImagePath = await convertToWebp(sourceImagePath, tempDirectory, "near-lossless");
+			break;
+	}
+	if (await getSizeBytes(workingImagePath) <= maxFileSizeBytes) {
+		const destinationImagePath = path.join(destinationDirectory, path.basename(workingImagePath));
+		await fse.copyFile(workingImagePath, destinationImagePath);
+		await fse.rm(tempDirectory, {
+			force: true,
+			recursive: true
+		});
+		return {
+			compression: "near-lossless",
+			path: destinationImagePath
+		};
+	}
+	if (workingImagePath !== sourceImagePath) await fse.rm(workingImagePath);
+	switch (lossyFormat) {
+		case "avif":
+			workingImagePath = await convertToAvif(sourceImagePath, tempDirectory, lossyQuality, true);
+			break;
+		case "jpeg":
+			workingImagePath = await convertToJpeg(sourceImagePath, tempDirectory, lossyQuality, true, "mozjpeg");
+			break;
+		case "none":
+			workingImagePath = sourceImagePath;
+			break;
+		case "webp":
+			workingImagePath = await convertToWebp(sourceImagePath, tempDirectory, lossyQuality, true);
+			break;
+	}
+	const destinationImagePath = path.join(destinationDirectory, path.basename(workingImagePath));
+	await fse.copyFile(workingImagePath, destinationImagePath);
+	await fse.rm(tempDirectory, {
+		force: true,
+		recursive: true
+	});
+	return {
+		compression: lossyFormat === "none" ? "none" : "lossy",
+		path: destinationImagePath
+	};
+}
+//#endregion
+//#region src/utilities/image/compare.ts
+const SSIM_REGEX = /All:\s*([\d.]+)/;
+const PSNR_REGEX = /average:\s*([\d.]+)/;
+/**
+* Get two identically sized PNGs from two images.
+* Uses the smaller image size as the target size.
+* Remember to clean up temp
+*/
+async function getTwoIdenticallySizedPng(image1, image2) {
+	const tempDirectory1 = await fse.mkdtemp(path.join(os.tmpdir(), `com.kitschpatrol.aphex.get-two-identically-sized-png.${getSlugFilename(image1)}.`));
+	const tempDirectory2 = await fse.mkdtemp(path.join(os.tmpdir(), `com.kitschpatrol.aphex.get-two-identically-sized-png.${getSlugFilename(image2)}.`));
+	const { width: w1, height: h1 } = await getImageDimensions(image1);
+	const { width: w2, height: h2 } = await getImageDimensions(image2);
+	const targetWidth = Math.min(w1, w2);
+	const targetHeight = Math.min(h1, h2);
+	return {
+		image1Png: await convertToPng(image1, tempDirectory1, false, targetWidth, targetHeight),
+		image2Png: await convertToPng(image2, tempDirectory2, false, targetWidth, targetHeight)
+	};
+}
+/**
+* Check if two images have the same pixel dimensions.
+*/
+async function isIdenticalSize(image1, image2) {
+	const { width: w1, height: h1 } = await getImageDimensions(image1);
+	const { width: w2, height: h2 } = await getImageDimensions(image2);
+	return h1 === h2 && w1 === w2;
+}
+/**
+* Quantify the similarity between two images.
+*
+* Bundles image conversion for performance across several measurements
+*/
+async function calculateSimilarity(image1, image2) {
+	const { image1Png, image2Png } = await getTwoIdenticallySizedPng(image1, image2);
+	try {
+		const [dssim, ssim, psnr] = await Promise.all([
+			calculateDSSIMInternal(image1Png, image2Png),
+			calculateSSIMInternal(image1Png, image2Png),
+			calculatePSNRInternal(image1Png, image2Png)
+		]);
+		return {
+			dssim,
+			psnr,
+			ssim
+		};
+	} finally {
+		await fse.rm(path.dirname(image1Png), {
+			force: true,
+			recursive: true
+		});
+		await fse.rm(path.dirname(image2Png), {
+			force: true,
+			recursive: true
+		});
+	}
+}
+async function calculateDSSIMInternal(image1, image2) {
+	lookupImageMimeType(image1, ["png"]);
+	lookupImageMimeType(image2, ["png"]);
+	if (!await isIdenticalSize(image1, image2)) {
+		log.error(`Images are not the same size:\n${image1}\n${image2}`);
+		return -1;
+	}
+	const { stdout } = await execa("dssim", [image1, image2]);
+	const [dssimIndex] = stdout.split("	");
+	if (dssimIndex === void 0) throw new Error("DSSIM index not found in dssim output.");
+	return Number.parseFloat(dssimIndex);
+}
+async function calculateSSIMInternal(image1, image2) {
+	lookupImageMimeType(image1, ["png"]);
+	lookupImageMimeType(image2, ["png"]);
+	if (!await isIdenticalSize(image1, image2)) {
+		log.error(`Images are not the same size:\n${image1}\n${image2}`);
+		return -1;
+	}
+	const result = await execa("ffmpeg", [
+		"-i",
+		image1,
+		"-i",
+		image2,
+		"-filter_complex",
+		"ssim",
+		"-f",
+		"null",
+		"-"
+	]);
+	const match = SSIM_REGEX.exec(result.stderr);
+	return match?.[1] ? Number.parseFloat(match[1]) : 0;
+}
+/**
+* Calculates the PSNR between two images using ffmpeg.
+*/
+async function calculatePSNRInternal(image1, image2) {
+	lookupImageMimeType(image1, ["png"]);
+	lookupImageMimeType(image2, ["png"]);
+	if (!await isIdenticalSize(image1, image2)) {
+		log.error(`Images are not the same size:\n${image1}\n${image2}`);
+		return -1;
+	}
+	const result = await execa("ffmpeg", [
+		"-i",
+		image1,
+		"-i",
+		image2,
+		"-filter_complex",
+		"psnr",
+		"-f",
+		"null",
+		"-"
+	]);
+	const match = PSNR_REGEX.exec(result.stderr);
+	return match?.[1] ? Number.parseFloat(match[1]) : 0;
+}
+//#endregion
+//#region src/pipeline/image-process.ts
+const defaultProcessImageOptions = {
+	defaultColorProfile: "sRGB IEC61966-2.1",
+	forceCompression: false,
+	logSimilarity: false,
+	losslessFormat: "webp",
+	losslessFormatAlpha: "png",
+	lossyFormat: "jpeg",
+	lossyFormatAlpha: "webp",
+	lossyQuality: .95,
+	maxDimensionsPixels: {
+		width: Number.MAX_SAFE_INTEGER,
+		height: Number.MAX_SAFE_INTEGER
+	},
+	maxFileSizeBytes: Number.MAX_SAFE_INTEGER,
+	nearLosslessFormat: "none",
+	nearLosslessFormatAlpha: "none",
+	passthroughFormats: [],
+	preserveColorProfiles: ["sRGB IEC61966-2.1"]
+};
+/**
+* Process one or more exported photos
+*/
+async function processPhotos(imagePaths, destinationDirectory, options) {
+	const resolvedOptions = mergeDefaults(options, defaultProcessImageOptions);
+	const tempProcessOutputDirectory = await getTempDirectory("process", "images");
+	let processImageResults;
+	try {
+		if (imagePaths.length === 1) processImageResults = [await processImage(imagePaths[0], tempProcessOutputDirectory, resolvedOptions)];
+		else {
+			const threads = Math.floor(os.availableParallelism() * .5);
+			log.debug(`Using ${threads} threads for processing`);
+			const piscina = new Piscina({
+				env: {
+					...process.env,
+					PISCINA_WORKER_META_URL: import.meta.url
+				},
+				filename: new URL(path.join(getPackageWorkersPath(import.meta), "process-image-worker.js"), "file://").href,
+				maxThreads: threads,
+				minThreads: threads
+			});
+			try {
+				processImageResults = await Promise.all(imagePaths.map(async (path) => piscina.run({
+					destinationDirectory: tempProcessOutputDirectory,
+					options: resolvedOptions,
+					sourceImagePath: path,
+					verbose: log.isLevelEnabled("debug")
+				})));
+			} finally {
+				await piscina.destroy();
+			}
+		}
+		const resolvedDestinationDirectory = await ensureDirectoryExists(destinationDirectory);
+		for (const result of processImageResults) {
+			const finalOutputPath = path.join(resolvedDestinationDirectory, path.basename(result.output.path));
+			await fse.move(result.path, finalOutputPath, { overwrite: true });
+			result.path = finalOutputPath;
+		}
+	} finally {
+		await fse.rm(tempProcessOutputDirectory, {
+			force: true,
+			recursive: true
+		});
+		const sipsTempFileCount = await sipsTempCleanup();
+		log.debug(`Cleaned up ${sipsTempFileCount} probable SIPS temp files from "${os.tmpdir()}"`);
+	}
+	return processImageResults;
+}
+/**
+* Process an image
+*
+* Run in parallel through a worker for album processing
+*/
+async function processImage(sourceImagePath, destinationDirectory, options) {
+	const startTime = performance.now();
+	const input = await getImageInfo(sourceImagePath);
+	const report = { date: /* @__PURE__ */ new Date() };
+	let workingImagePath = sourceImagePath;
+	const tempDirectory = await getTempDirectory("process", "image");
+	if (options.passthroughFormats.includes("png") && input.mime === "png") workingImagePath = await optimizePng(workingImagePath, tempDirectory);
+	const isOverweight = input.sizeBytes > options.maxFileSizeBytes;
+	const isOversize = input.dimensionsPixels.width > options.maxDimensionsPixels.width || input.dimensionsPixels.height > options.maxDimensionsPixels.height;
+	const isInvalidColorProfile = await needsColorConversion(workingImagePath, options.preserveColorProfiles);
+	const isInvalidOutputFormat = !options.passthroughFormats.includes(input.mime);
+	if (input.mime !== "png" && (isInvalidOutputFormat || isOverweight || isInvalidColorProfile || isOversize && isOverweight)) {
+		workingImagePath = await convertToPng(workingImagePath, tempDirectory);
+		workingImagePath = await optimizePng(workingImagePath, tempDirectory);
+	} else {
+		workingImagePath = path.join(tempDirectory, path.basename(sourceImagePath));
+		await fse.copyFile(sourceImagePath, workingImagePath);
+	}
+	report.color = await normalizeColorProfile(workingImagePath, options.preserveColorProfiles, options.defaultColorProfile);
+	const normalizedColorProfile = await getColorProfile(workingImagePath);
+	if (isInvalidOutputFormat || isOverweight || isInvalidColorProfile || isOversize && isOverweight) {
+		if (isOversize) workingImagePath = await resizePngToFit(workingImagePath, tempDirectory, options.maxDimensionsPixels.width, options.maxDimensionsPixels.height);
+		const compressionResult = await compressImage(workingImagePath, tempDirectory, {
+			forceCompression: options.forceCompression,
+			losslessFormat: input.alpha ? options.losslessFormatAlpha : options.losslessFormat,
+			lossyFormat: input.alpha ? options.lossyFormatAlpha : options.lossyFormat,
+			lossyQuality: options.lossyQuality,
+			maxFileSizeBytes: options.maxFileSizeBytes,
+			nearLosslessFormat: input.alpha ? options.nearLosslessFormatAlpha : options.nearLosslessFormat
+		});
+		workingImagePath = compressionResult.path;
+		report.compression = compressionResult.compression;
+	} else report.compression = "none";
+	await stripTags(workingImagePath);
+	await assignColorProfile(workingImagePath, normalizedColorProfile);
+	const destinationImagePath = path.join(destinationDirectory, path.basename(workingImagePath));
+	await fse.copyFile(workingImagePath, destinationImagePath);
+	await fse.rm(tempDirectory, {
+		force: true,
+		recursive: true
+	});
+	const output = await getImageInfo(destinationImagePath);
+	if (options.logSimilarity && (report.compression === "lossy" || report.compression === "near-lossless")) {
+		const { dssim, psnr, ssim } = await calculateSimilarity(sourceImagePath, destinationImagePath);
+		report.similarity = {
+			dssim,
+			psnr,
+			ssim
+		};
+	}
+	report.durationMs = Math.round(performance.now() - startTime);
+	if (!isProcessImageResultReport(report)) throw new Error("Invalid report");
+	return {
+		input,
+		output,
+		path: destinationImagePath,
+		report
+	};
+}
+function isProcessImageResultReport(object) {
+	if (!(object.color !== void 0 && object.compression !== void 0 && object.date instanceof Date && typeof object.durationMs === "number")) return false;
+	if (object.similarity !== void 0) return typeof object.similarity.dssim === "number" && typeof object.similarity.psnr === "number" && typeof object.similarity.ssim === "number";
+	return true;
+}
+//#endregion
+//#region src/pipeline/image-sync.ts
+async function getDestinationFiles(destinationDirectory) {
+	const files = (await fse.readdir(destinationDirectory, { withFileTypes: true })).filter((entry) => entry.isFile());
+	return Promise.all(files.map(async (file) => {
+		const filePath = path.join(destinationDirectory, file.name);
+		if (!await fse.pathExists(filePath)) return {
+			filePath,
+			tags: void 0
+		};
+		try {
+			return {
+				filePath,
+				tags: await getTags(filePath)
+			};
+		} catch {
+			return {
+				filePath,
+				tags: void 0
+			};
+		}
+	}));
+}
+/**
+* Create a sync plan
+*
+* TODO how to handle non-image files?
+*/
+async function getSyncPlanForImages(identifiers, destinationDirectory, options, exportOptions) {
+	const resolvedOptions = mergeDefaults(options, defaultSyncOptions);
+	const resolvedExportOptions = mergeDefaults(exportOptions, defaultExportOptions);
+	const photoInfos = await resolveIdentifiers(identifiers);
+	const syncResult = {
+		plan: [],
+		toDelete: []
+	};
+	const destinationFiles = await getDestinationFiles(destinationDirectory);
+	for (const sourcePhotoInfo of photoInfos) {
+		const matchingDestinationFile = destinationFiles.find((file) => file.tags?.aphexMetadata?.photoInfo.uuid === sourcePhotoInfo.uuid);
+		if (matchingDestinationFile === void 0) {
+			syncResult.plan.push({
+				diffedVia: void 0,
+				matchFilePath: void 0,
+				photoInfo: sourcePhotoInfo,
+				status: "new"
+			});
+			continue;
+		}
+		const sourcePhotoFileBaseName = stripExtension(getImagePathWithFileName(sourcePhotoInfo, "", resolvedExportOptions.exportOptions.fileNameSluggify, resolvedExportOptions.exportOptions.fileNameAppendUuidFragment, resolvedExportOptions.exportOptions.fileNameNormalizeExtensions, resolvedExportOptions.exportOptions.fileNamePrecedence));
+		const differenceFound = await isDifferent(resolvedOptions.diffStrategies, sourcePhotoInfo, sourcePhotoFileBaseName, matchingDestinationFile.filePath, matchingDestinationFile.tags, resolvedExportOptions, resolvedOptions.forceUpdate);
+		if (differenceFound) {
+			if (resolvedOptions.deleteTarget) syncResult.toDelete.push(matchingDestinationFile.filePath);
+			syncResult.plan.push({
+				diffedVia: differenceFound,
+				matchFilePath: matchingDestinationFile.filePath,
+				photoInfo: sourcePhotoInfo,
+				status: "changed"
+			});
+			continue;
+		}
+		syncResult.plan.push({
+			diffedVia: void 0,
+			matchFilePath: matchingDestinationFile.filePath,
+			photoInfo: sourcePhotoInfo,
+			status: "unchanged"
+		});
+	}
+	if (resolvedOptions.deleteOthers) syncResult.toDelete = [...syncResult.toDelete, ...destinationFiles.filter((file) => !syncResult.plan.some((plan) => plan.matchFilePath === file.filePath)).map((file) => file.filePath)];
+	syncResult.toDelete = [...new Set(syncResult.toDelete)];
+	return syncResult;
+}
+/**
+* See if there's a difference between the source image and the target image
+* @returns Undefined if the, or the reason for the difference if found
+*/
+async function isDifferent(diffStrategies, sourcePhotoInfo, sourcePhotoFileBaseName, matchPhotoFilePath, matchPhotoTags, exportOptions, forceUpdate) {
+	let sourceTags;
+	if (forceUpdate) return "force-update";
+	for (const diffStrategy of diffStrategies) switch (diffStrategy) {
+		case "exif-tags":
+			sourceTags ??= await getTags(sourcePhotoInfo.original.filePath);
+			if (matchPhotoTags === void 0 || sourceTags.credit !== matchPhotoTags.credit || sourceTags.creator !== matchPhotoTags.creator || sourceTags.description !== matchPhotoTags.description || sourceTags.preservedFileName !== matchPhotoTags.preservedFileName || sourceTags.label !== matchPhotoTags.label) return diffStrategy;
+			break;
+		case "export-options":
+			if (matchPhotoTags === void 0 || !deepEqual(exportOptions.exportOptions, matchPhotoTags.aphexMetadata?.exportOptions.exportOptions)) return diffStrategy;
+			break;
+		case "file-name":
+			if (stripExtension(path.basename(matchPhotoFilePath)) !== sourcePhotoFileBaseName) return diffStrategy;
+			break;
+		case "force-update": return diffStrategy;
+		case "metadata-options":
+			sourceTags ??= await getTags(sourcePhotoInfo.original.filePath);
+			if (matchPhotoTags === void 0 || !deepEqual(exportOptions.metadataOptions, matchPhotoTags.aphexMetadata?.exportOptions.metadataOptions)) return diffStrategy;
+			break;
+		case "photo-info":
+			if (matchPhotoTags === void 0 || !deepEqual(sourcePhotoInfo, matchPhotoTags.aphexMetadata?.photoInfo)) return diffStrategy;
+			break;
+		case "process-options":
+			if (matchPhotoTags === void 0 || !deepEqual(exportOptions.processOptions, matchPhotoTags.aphexMetadata?.exportOptions.processOptions)) return diffStrategy;
+			break;
+	}
+	return false;
+}
+//#endregion
+//#region src/index.ts
+/**
+* Helper for deep merging ExportOptions object against library defaults.
+* Exported for unplugin-aphex.
+*/
+function mergeDefaultExportOptions(options) {
+	return mergeDefaults(options, defaultExportOptions);
+}
+const defaultSyncOptions = {
+	deleteOthers: false,
+	deleteTarget: true,
+	diffStrategies: [
+		"file-name",
+		"photo-info",
+		"export-options",
+		"process-options",
+		"metadata-options",
+		"exif-tags"
+	],
+	forceUpdate: false
+};
+const defaultExportOptions = {
+	exportOptions: defaultExportApplePhotoOptions,
+	metadataOptions: defaultManageMetadataOptions,
+	processOptions: defaultProcessImageOptions,
+	syncOptions: defaultSyncOptions
+};
+/**
+* Export a single photo
+*/
+async function exportPhoto(identifier, destinationDirectory, options) {
+	const result = await exportPhotos([await resolvePhotoIdentifier(identifier)], destinationDirectory, options);
+	assertSingleElement(result);
+	return result[0];
+}
+/**
+* Export photos
+*/
+async function exportPhotos(identifiers, destinationDirectory, options) {
+	const resolvedOptions = mergeDefaultExportOptions(options);
+	const { exportOptions, metadataOptions, processOptions, syncOptions } = resolvedOptions;
+	const resolvedDestinationDirectory = await ensureDirectoryExists(destinationDirectory);
+	const photoInfos = await resolveIdentifiers(identifiers);
+	let syncResult;
+	if (syncOptions !== "disabled") {
+		syncResult = await getSyncPlanForImages(photoInfos, resolvedDestinationDirectory, syncOptions, resolvedOptions);
+		await Promise.all(syncResult.toDelete.map(async (file) => fse.rm(file, { force: true })));
+		if (syncResult.plan.length !== photoInfos.length) throw new Error("Sync plan length does not match photos length");
+	}
+	const exportResults = photoInfos.map((photoInfo, index) => {
+		const syncPlan = syncResult?.plan[index];
+		return {
+			options: resolvedOptions,
+			path: syncPlan?.status === "unchanged" ? syncPlan.matchFilePath ?? "" : "",
+			photoInfo,
+			results: {
+				exportResult: void 0,
+				metadataResult: void 0,
+				processResult: void 0,
+				syncResult: syncPlan ? cleanSyncResult(syncPlan) : void 0
+			}
+		};
+	});
+	if (exportResults.every((exportResult) => exportResult.results.syncResult?.status === "unchanged")) return exportResults;
+	const seenBaseNames = /* @__PURE__ */ new Set();
+	let hasCollision = false;
+	for (const exportResult of exportResults) {
+		if (exportResult.results.syncResult?.status === "unchanged") continue;
+		const baseName = path.basename(getImagePathWithFileName(exportResult.photoInfo, "placeholder.jpg", exportOptions.fileNameSluggify, exportOptions.fileNameAppendUuidFragment, exportOptions.fileNameNormalizeExtensions, exportOptions.fileNamePrecedence), path.extname("placeholder.jpg"));
+		if (seenBaseNames.has(baseName)) {
+			hasCollision = true;
+			break;
+		}
+		seenBaseNames.add(baseName);
+	}
+	if (hasCollision && !exportOptions.fileNameAppendUuidFragment) {
+		log.warn("Name collision detected among exported photos, enabling UUID fragment to disambiguate");
+		exportOptions.fileNameAppendUuidFragment = true;
+	}
+	const exportDirectory = processOptions === "disabled" ? resolvedDestinationDirectory : await getTempDirectory("export-photo");
+	const applePhotosExportResults = await exportApplePhotos(exportResults.filter((exportResult) => exportResult.results.syncResult?.status !== "unchanged").map((exportResult) => exportResult.photoInfo), exportDirectory, exportOptions);
+	for (const exportResult of exportResults) {
+		if (exportResult.results.syncResult?.status === "unchanged") continue;
+		const matchingExportResult = applePhotosExportResults.find((photoExportResult) => photoExportResult.photoInfo.uuid === exportResult.photoInfo.uuid);
+		if (matchingExportResult) {
+			exportResult.path = matchingExportResult.path;
+			exportResult.results.exportResult = cleanExportResults(matchingExportResult);
+		} else log.warn(`No export result found for photo "${exportResult.photoInfo.title ?? exportResult.photoInfo.uuid}"`);
+	}
+	let processResults;
+	if (processOptions !== "disabled") {
+		processResults = await processPhotos(exportResults.filter((exportResult) => exportResult.results.syncResult?.status !== "unchanged").map((exportResult) => exportResult.path), destinationDirectory, processOptions);
+		await fse.rm(exportDirectory, {
+			force: true,
+			recursive: true
+		});
+		for (const exportResult of exportResults) {
+			if (exportResult.results.syncResult?.status === "unchanged") continue;
+			const matchingProcessResult = processResults.find((processResult) => stripExtension(path.basename(processResult.path)) === stripExtension(path.basename(exportResult.path)));
+			if (matchingProcessResult) {
+				exportResult.path = matchingProcessResult.path;
+				exportResult.results.processResult = cleanProcessResults(matchingProcessResult);
+			} else log.warn(`No process result found for photo "${exportResult.photoInfo.title ?? exportResult.photoInfo.uuid}"`);
+		}
+	}
+	let metadataResults;
+	if (metadataOptions !== "disabled") {
+		const targetPhotos = exportResults.filter((exportResult) => exportResult.results.syncResult?.status !== "unchanged");
+		metadataResults = await manageMetadataBatch(targetPhotos.map((exportResult) => exportResult.photoInfo), targetPhotos.map((exportResult) => exportResult.path), metadataOptions, resolvedOptions);
+		for (const exportResult of exportResults) {
+			const matchingMetadataResult = metadataResults.find((photoExportResult) => photoExportResult.photoInfo.uuid === exportResult.photoInfo.uuid);
+			if (matchingMetadataResult) exportResult.results.metadataResult = cleanMetadataResults(matchingMetadataResult);
+		}
+	}
+	return exportResults;
+}
+function cleanExportResults(result) {
+	return { exportEngine: result.exportEngine };
+}
+function cleanMetadataResults(result) {
+	const { photoInfo: _, ...rest } = result;
+	return { ...rest };
+}
+function cleanSyncResult(result) {
+	const { photoInfo: _, ...rest } = result;
+	return { ...rest };
+}
+function cleanProcessResults(result) {
+	if (result === void 0) return;
+	const { input, output, path: _path, ...rest } = result;
+	const { path: _inputPath, ...strippedInput } = input;
+	const { path: _outputPath, ...strippedOutput } = output;
+	return {
+		...rest,
+		input: strippedInput,
+		output: strippedOutput
+	};
+}
+//#endregion
+export { IMAGE_MIME_TYPES, defaultExportOptions, defaultSyncOptions, endExiftool, exportPhoto, exportPhotos, aphexAlbumInfo as getAlbumInfo, aphexPhotoInfo as getPhotoInfo, interactiveSessionStart, interactiveSessionStop, mergeDefaultExportOptions, processImage, setLogger };