@hot-updater/aws 0.20.11 → 0.20.12

package/dist/iac/index.cjs

@@ -24,8 +24,6 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 }) : target, mod));
 
 //#endregion
-let fs = require("fs");
-fs = __toESM(fs);
 let __aws_sdk_credential_providers = require("@aws-sdk/credential-providers");
 __aws_sdk_credential_providers = __toESM(__aws_sdk_credential_providers);
 let node_util = require("node:util");
@@ -48,6 +46,8 @@ let node_path = require("node:path");
 node_path = __toESM(node_path);
 let path = require("path");
 path = __toESM(path);
+let fs = require("fs");
+fs = __toESM(fs);
 let node_timers_promises = require("node:timers/promises");
 node_timers_promises = __toESM(node_timers_promises);
 let node_os = require("node:os");
@@ -64,10 +64,10 @@ let node_stream = require("node:stream");
 node_stream = __toESM(node_stream);
 let node_buffer = require("node:buffer");
 node_buffer = __toESM(node_buffer);
-let crypto = require("crypto");
-crypto = __toESM(crypto);
 let __aws_sdk_client_cloudfront = require("@aws-sdk/client-cloudfront");
 __aws_sdk_client_cloudfront = __toESM(__aws_sdk_client_cloudfront);
+let crypto = require("crypto");
+crypto = __toESM(crypto);
 let __aws_sdk_client_iam = require("@aws-sdk/client-iam");
 __aws_sdk_client_iam = __toESM(__aws_sdk_client_iam);
 let __aws_sdk_client_lambda = require("@aws-sdk/client-lambda");
@@ -473,16 +473,16 @@ function G(t, u$2, F$1) {
 `).map((e$1) => oD(e$1, u$2, F$1)).join(`
 `);
 }
-const aD = [
-	"up",
-	"down",
-	"left",
-	"right",
-	"space",
-	"enter",
-	"cancel"
-], c$1 = {
-	actions: new Set(aD),
+const c$1 = {
+	actions: new Set([
+		"up",
+		"down",
+		"left",
+		"right",
+		"space",
+		"enter",
+		"cancel"
+	]),
 	aliases: new Map([
 		["k", "up"],
 		["j", "down"],
@@ -522,9 +522,8 @@ function cD({ input: t = node_process.stdin, output: u$2 = node_process.stdout,
 	});
 	node_readline.emitKeypressEvents(t, s), t.isTTY && t.setRawMode(!0);
 	const i$1 = (D$1, { name: C$1, sequence: o$2 }) => {
-		const E = String(D$1);
 		if (k$1([
-			E,
+			String(D$1),
 			C$1,
 			o$2
 		], "cancel")) {
@@ -713,10 +712,7 @@ let dD = class extends x {
 		if (u$2.group === !0) {
 			const F$1 = u$2.value, e$1 = this.getGroupItems(F$1);
 			this.isGroupSelected(F$1) ? this.value = this.value.filter((s) => e$1.findIndex((i$1) => i$1.value === s) === -1) : this.value = [...this.value, ...e$1.map((s) => s.value)], this.value = Array.from(new Set(this.value));
-		} else {
-			const F$1 = this.value.includes(u$2.value);
-			this.value = F$1 ? this.value.filter((e$1) => e$1 !== u$2.value) : [...this.value, u$2.value];
-		}
+		} else this.value = this.value.includes(u$2.value) ? this.value.filter((e$1) => e$1 !== u$2.value) : [...this.value, u$2.value];
 	}
 };
 var bD = Object.defineProperty, mD = (t, u$2, F$1) => u$2 in t ? bD(t, u$2, {
@@ -749,12 +745,10 @@ let wD = class extends x {
 		return this.options[this.cursor].value;
 	}
 	toggleAll() {
-		const u$2 = this.value.length === this.options.length;
-		this.value = u$2 ? [] : this.options.map((F$1) => F$1.value);
+		this.value = this.value.length === this.options.length ? [] : this.options.map((F$1) => F$1.value);
 	}
 	toggleValue() {
-		const u$2 = this.value.includes(this._value);
-		this.value = u$2 ? this.value.filter((F$1) => F$1 !== this._value) : [...this.value, this._value];
+		this.value = this.value.includes(this._value) ? this.value.filter((F$1) => F$1 !== this._value) : [...this.value, this._value];
 	}
 };
 var yD = Object.defineProperty, _D = (t, u$2, F$1) => u$2 in t ? yD(t, u$2, {
@@ -1181,8 +1175,7 @@ ${J}${r$1.trimStart()}`), s = 3 + (0, node_util.stripVTControlCharacters)(r$1.tr
 	], s = V ? 80 : 120, r$1 = process.env.CI === "true";
 	let i$1, a$1, c$2 = !1, l$1 = "", $$2, p$1 = performance.now();
 	const M$1 = (m$1) => {
-		const h$2 = m$1 > 1 ? "Something went wrong" : "Canceled";
-		c$2 && N$1(h$2, m$1);
+		c$2 && N$1(m$1 > 1 ? "Something went wrong" : "Canceled", m$1);
 	}, v$1 = () => M$1(2), x$1 = () => M$1(1), j$1 = () => {
 		process.on("uncaughtExceptionMonitor", v$1), process.on("unhandledRejection", v$1), process.on("SIGINT", x$1), process.on("SIGTERM", x$1), process.on("exit", M$1);
 	}, E = () => {
@@ -1298,8 +1291,7 @@ const stringToUint8Array = (string) => textEncoder$1.encode(string);
 const textDecoder = new TextDecoder();
 const uint8ArrayToString = (uint8Array) => textDecoder.decode(uint8Array);
 const joinToString = (uint8ArraysOrStrings, encoding) => {
-	const strings = uint8ArraysToStrings(uint8ArraysOrStrings, encoding);
-	return strings.join("");
+	return uint8ArraysToStrings(uint8ArraysOrStrings, encoding).join("");
 };
 const uint8ArraysToStrings = (uint8ArraysOrStrings, encoding) => {
 	if (encoding === "utf8" && uint8ArraysOrStrings.every((uint8ArrayOrString) => typeof uint8ArrayOrString === "string")) return uint8ArraysOrStrings;
@@ -1354,8 +1346,7 @@ const parseTemplate = ({ templates, expressions, tokens, index, template }) => {
 	const newTokens = concatTokens(tokens, nextTokens, leadingWhitespaces);
 	if (index === expressions.length) return newTokens;
 	const expression = expressions[index];
-	const expressionTokens = Array.isArray(expression) ? expression.map((expression$1) => parseExpression(expression$1)) : [parseExpression(expression)];
-	return concatTokens(newTokens, expressionTokens, trailingWhitespaces);
+	return concatTokens(newTokens, Array.isArray(expression) ? expression.map((expression$1) => parseExpression(expression$1)) : [parseExpression(expression)], trailingWhitespaces);
 };
 const splitByWhitespaces = (template, rawTemplate) => {
 	if (rawTemplate.length === 0) return {
@@ -1442,8 +1433,7 @@ const normalizeFdSpecificOptions = (options) => {
 };
 const normalizeFdSpecificOption = (options, optionName) => {
 	const optionBaseArray = Array.from({ length: getStdioLength(options) + 1 });
-	const optionArray = normalizeFdSpecificValue(options[optionName], optionBaseArray, optionName);
-	return addDefaultValue$1(optionArray, optionName);
+	return addDefaultValue$1(normalizeFdSpecificValue(options[optionName], optionBaseArray, optionName), optionName);
 };
 const getStdioLength = ({ stdio }) => Array.isArray(stdio) ? Math.max(stdio.length, STANDARD_STREAMS_ALIASES.length) : STANDARD_STREAMS_ALIASES.length;
 const normalizeFdSpecificValue = (optionValue, optionArray, optionName) => isPlainObject$1(optionValue) ? normalizeOptionObject(optionValue, optionArray, optionName) : optionArray.fill(optionValue);
@@ -1473,12 +1463,11 @@ const parseFd = (fdName) => {
 };
 const FD_REGEXP = /^fd(\d+)$/;
 const addDefaultValue$1 = (optionArray, optionName) => optionArray.map((optionValue) => optionValue === void 0 ? DEFAULT_OPTIONS[optionName] : optionValue);
-const verboseDefault = (0, node_util.debuglog)("execa").enabled ? "full" : "none";
 const DEFAULT_OPTIONS = {
 	lines: false,
 	buffer: true,
 	maxBuffer: 1e3 * 1e3 * 100,
-	verbose: verboseDefault,
+	verbose: (0, node_util.debuglog)("execa").enabled ? "full" : "none",
 	stripFinalNewline: true
 };
 const FD_SPECIFIC_OPTIONS = [
@@ -1511,11 +1500,9 @@ const VERBOSE_VALUES = [
 //#region ../../node_modules/.pnpm/execa@9.5.2/node_modules/execa/lib/arguments/escape.js
 const joinCommand = (filePath, rawArguments) => {
 	const fileAndArguments = [filePath, ...rawArguments];
-	const command = fileAndArguments.join(" ");
-	const escapedCommand = fileAndArguments.map((fileAndArgument) => quoteString(escapeControlCharacters(fileAndArgument))).join(" ");
 	return {
-		command,
-		escapedCommand
+		command: fileAndArguments.join(" "),
+		escapedCommand: fileAndArguments.map((fileAndArgument) => quoteString(escapeControlCharacters(fileAndArgument))).join(" ")
 	};
 };
 const escapeLines = (lines) => (0, node_util.stripVTControlCharacters)(lines).split("\n").map((line) => escapeControlCharacters(line)).join("\n");
@@ -1956,13 +1943,11 @@ const appendNewline = (printedLine) => printedLine.endsWith("\n") ? printedLine
 //#endregion
 //#region ../../node_modules/.pnpm/execa@9.5.2/node_modules/execa/lib/verbose/log.js
 const verboseLog = ({ type, verboseMessage, fdNumber, verboseInfo, result }) => {
-	const verboseObject = getVerboseObject({
+	const finalLines = applyVerboseOnLines(getPrintedLines(verboseMessage, getVerboseObject({
 		type,
 		result,
 		verboseInfo
-	});
-	const printedLines = getPrintedLines(verboseMessage, verboseObject);
-	const finalLines = applyVerboseOnLines(printedLines, verboseInfo, fdNumber);
+	})), verboseInfo, fdNumber);
 	if (finalLines !== "") console.warn(finalLines.slice(0, -1));
 };
 const getVerboseObject = ({ type, result, verboseInfo: { escapedCommand, commandId, rawOptions: { piped = false,...options } } }) => ({
@@ -1979,16 +1964,13 @@ const getPrintedLines = (verboseMessage, verboseObject) => verboseMessage.split(
 	message
 }));
 const getPrintedLine = (verboseObject) => {
-	const verboseLine = defaultVerboseFunction(verboseObject);
 	return {
-		verboseLine,
+		verboseLine: defaultVerboseFunction(verboseObject),
 		verboseObject
 	};
 };
 const serializeVerboseMessage = (message) => {
-	const messageString = typeof message === "string" ? message : (0, node_util.inspect)(message);
-	const escapedMessage = escapeLines(messageString);
-	return escapedMessage.replaceAll("	", " ".repeat(TAB_SIZE));
+	return escapeLines(typeof message === "string" ? message : (0, node_util.inspect)(message)).replaceAll("	", " ".repeat(TAB_SIZE));
 };
 const TAB_SIZE = 2;
 
@@ -2007,11 +1989,10 @@ const logCommand = (escapedCommand, verboseInfo) => {
 //#region ../../node_modules/.pnpm/execa@9.5.2/node_modules/execa/lib/verbose/info.js
 const getVerboseInfo = (verbose, escapedCommand, rawOptions) => {
 	validateVerbose(verbose);
-	const commandId = getCommandId(verbose);
 	return {
 		verbose,
 		escapedCommand,
-		commandId,
+		commandId: getCommandId(verbose),
 		rawOptions
 	};
 };
@@ -2038,8 +2019,7 @@ const getDurationMs = (startTime) => Number(node_process.hrtime.bigint() - start
 const handleCommand = (filePath, rawArguments, rawOptions) => {
 	const startTime = getStartTime();
 	const { command, escapedCommand } = joinCommand(filePath, rawArguments);
-	const verbose = normalizeFdSpecificOption(rawOptions, "verbose");
-	const verboseInfo = getVerboseInfo(verbose, escapedCommand, { ...rawOptions });
+	const verboseInfo = getVerboseInfo(normalizeFdSpecificOption(rawOptions, "verbose"), escapedCommand, { ...rawOptions });
 	logCommand(escapedCommand, verboseInfo);
 	return {
 		command,
@@ -2107,8 +2087,7 @@ var require_mode = /* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm/isexe@
 		var g$2 = parseInt("010", 8);
 		var o$2 = parseInt("001", 8);
 		var ug = u$2 | g$2;
-		var ret = mod & o$2 || mod & g$2 && gid === myGid || mod & u$2 && uid === myUid || mod & ug && myUid === 0;
-		return ret;
+		return mod & o$2 || mod & g$2 && gid === myGid || mod & u$2 && uid === myUid || mod & ug && myUid === 0;
 	}
 }) });
 
@@ -2190,8 +2169,7 @@ var require_which = /* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm/which
 			const ppRaw = pathEnv[i$1];
 			const pathPart = /^".*"$/.test(ppRaw) ? ppRaw.slice(1, -1) : ppRaw;
 			const pCmd = path$9.join(pathPart, cmd);
-			const p$1 = !pathPart && /^\.[\\\/]/.test(cmd) ? cmd.slice(0, 2) + pCmd : pCmd;
-			resolve(subStep(p$1, i$1, 0));
+			resolve(subStep(!pathPart && /^\.[\\\/]/.test(cmd) ? cmd.slice(0, 2) + pCmd : pCmd, i$1, 0));
 		});
 		const subStep = (p$1, i$1, ii) => new Promise((resolve, reject) => {
 			if (ii === pathExt.length) return resolve(step(i$1 + 1));
@@ -2216,8 +2194,7 @@ var require_which = /* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm/which
 			for (let j$1 = 0; j$1 < pathExt.length; j$1++) {
 				const cur = p$1 + pathExt[j$1];
 				try {
-					const is = isexe.sync(cur, { pathExt: pathExtExe });
-					if (is) if (opt.all) found.push(cur);
+					if (isexe.sync(cur, { pathExt: pathExtExe })) if (opt.all) found.push(cur);
 					else return cur;
 				} catch (ex) {}
 			}
@@ -2235,8 +2212,7 @@ var require_which = /* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm/which
 var require_path_key = /* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm/path-key@3.1.1/node_modules/path-key/index.js": ((exports, module) => {
 	const pathKey$1 = (options = {}) => {
 		const environment = options.env || process.env;
-		const platform$1 = options.platform || process.platform;
-		if (platform$1 !== "win32") return "PATH";
+		if ((options.platform || process.platform) !== "win32") return "PATH";
 		return Object.keys(environment).reverse().find((key) => key.toUpperCase() === "PATH") || "Path";
 	};
 	module.exports = pathKey$1;
@@ -2364,12 +2340,11 @@ var require_parse = /* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm/cross
 			parsed.command = path$7.normalize(parsed.command);
 			parsed.command = escape.command(parsed.command);
 			parsed.args = parsed.args.map((arg) => escape.argument(arg, needsDoubleEscapeMetaChars));
-			const shellCommand = [parsed.command].concat(parsed.args).join(" ");
 			parsed.args = [
 				"/d",
 				"/s",
 				"/c",
-				`"${shellCommand}"`
+				`"${[parsed.command].concat(parsed.args).join(" ")}"`
 			];
 			parsed.command = process.env.comspec || "cmd.exe";
 			parsed.options.windowsVerbatimArguments = true;
@@ -2522,9 +2497,7 @@ const npmRunPathEnv = ({ env: env$1 = node_process.default.env,...options } = {}
 //#endregion
 //#region ../../node_modules/.pnpm/execa@9.5.2/node_modules/execa/lib/return/final-error.js
 const getFinalError = (originalError, message, isSync) => {
-	const ErrorClass = isSync ? ExecaSyncError : ExecaError;
-	const options = originalError instanceof DiscardedError ? {} : { cause: originalError };
-	return new ErrorClass(message, options);
+	return new (isSync ? ExecaSyncError : ExecaError)(message, originalError instanceof DiscardedError ? {} : { cause: originalError });
 };
 var DiscardedError = class extends Error {};
 const setErrorName = (ErrorClass, value) => {
@@ -2843,16 +2816,14 @@ const SIGNALS = [
 //#region ../../node_modules/.pnpm/human-signals@8.0.0/node_modules/human-signals/build/src/signals.js
 const getSignals = () => {
 	const realtimeSignals = getRealtimeSignals();
-	const signals$1 = [...SIGNALS, ...realtimeSignals].map(normalizeSignal$1);
-	return signals$1;
+	return [...SIGNALS, ...realtimeSignals].map(normalizeSignal$1);
 };
 const normalizeSignal$1 = ({ name, number: defaultNumber, description, action, forced = false, standard }) => {
 	const { signals: { [name]: constantSignal } } = node_os.constants;
 	const supported = constantSignal !== void 0;
-	const number = supported ? constantSignal : defaultNumber;
 	return {
 		name,
-		number,
+		number: supported ? constantSignal : defaultNumber,
 		description,
 		supported,
 		action,
@@ -3264,8 +3235,7 @@ const isConnected = (anyProcess) => {
 //#region ../../node_modules/.pnpm/execa@9.5.2/node_modules/execa/lib/ipc/strict.js
 const handleSendStrict = ({ anyProcess, channel, isSubprocess, message, strict }) => {
 	if (!strict) return message;
-	const ipcEmitter = getIpcEmitter(anyProcess, channel, isSubprocess);
-	const hasListeners = hasMessageListeners(anyProcess, ipcEmitter);
+	const hasListeners = hasMessageListeners(anyProcess, getIpcEmitter(anyProcess, channel, isSubprocess));
 	return {
 		id: count++,
 		type: REQUEST_TYPE,
@@ -3338,11 +3308,9 @@ const RESPONSE_TYPE = "execa:ipc:response";
 const startSendMessage = (anyProcess, wrappedMessage, strict) => {
 	if (!OUTGOING_MESSAGES.has(anyProcess)) OUTGOING_MESSAGES.set(anyProcess, /* @__PURE__ */ new Set());
 	const outgoingMessages = OUTGOING_MESSAGES.get(anyProcess);
-	const onMessageSent = createDeferred();
-	const id = strict ? wrappedMessage.id : void 0;
 	const outgoingMessage = {
-		onMessageSent,
-		id
+		onMessageSent: createDeferred(),
+		id: strict ? wrappedMessage.id : void 0
 	};
 	outgoingMessages.add(outgoingMessage);
 	return {
@@ -3503,8 +3471,7 @@ const throwOnGracefulCancel = ({ subprocess, cancelSignal, gracefulCancel, force
 })] : [];
 const sendOnAbort = async ({ subprocess, cancelSignal, forceKillAfterDelay, context, controller: { signal } }) => {
 	await onAbortedSignal(cancelSignal, signal);
-	const reason = getReason(cancelSignal);
-	await sendAbort(subprocess, reason);
+	await sendAbort(subprocess, getReason(cancelSignal));
 	killOnTimeout({
 		kill: subprocess.kill,
 		forceKillAfterDelay,
@@ -3678,8 +3645,7 @@ const normalizeOptions = (filePath, rawArguments, rawOptions) => {
 	rawOptions.cwd = normalizeCwd(rawOptions.cwd);
 	const [processedFile, processedArguments, processedOptions] = handleNodeOption(filePath, rawArguments, rawOptions);
 	const { command: file, args: commandArguments, options: initialOptions } = import_cross_spawn.default._parse(processedFile, processedArguments, processedOptions);
-	const fdOptions = normalizeFdSpecificOptions(initialOptions);
-	const options = addDefaultOptions(fdOptions);
+	const options = addDefaultOptions(normalizeFdSpecificOptions(initialOptions));
 	validateTimeout(options);
 	validateEncoding(options);
 	validateIpcInputOption(options);
@@ -3836,7 +3802,7 @@ const u = Object.create(a, {
 	}
 });
 function h({ preventCancel: r$1 = !1 } = {}) {
-	const e$1 = this.getReader(), t = new c(e$1, r$1), s = Object.create(u);
+	const t = new c(this.getReader(), r$1), s = Object.create(u);
 	return s[n] = t, s;
 }
 
@@ -3885,18 +3851,14 @@ const getStreamContents$1 = async (stream, { init, convertChunk, getSize, trunca
 	const state = init();
 	state.length = 0;
 	try {
-		for await (const chunk of asyncIterable) {
-			const chunkType = getChunkType(chunk);
-			const convertedChunk = convertChunk[chunkType](chunk, state);
-			appendChunk({
-				convertedChunk,
-				state,
-				getSize,
-				truncateChunk,
-				addChunk,
-				maxBuffer
-			});
-		}
+		for await (const chunk of asyncIterable) appendChunk({
+			convertedChunk: convertChunk[getChunkType(chunk)](chunk, state),
+			state,
+			getSize,
+			truncateChunk,
+			addChunk,
+			maxBuffer
+		});
 		appendFinalChunk({
 			state,
 			convertChunk,
@@ -4086,10 +4048,9 @@ const stringMethods = {
 const handleMaxBuffer = ({ error, stream, readableObjectMode, lines, encoding, fdNumber }) => {
 	if (!(error instanceof MaxBufferError)) throw error;
 	if (fdNumber === "all") return error;
-	const unit = getMaxBufferUnit(readableObjectMode, lines, encoding);
 	error.maxBufferInfo = {
 		fdNumber,
-		unit
+		unit: getMaxBufferUnit(readableObjectMode, lines, encoding)
 	};
 	stream.destroy();
 	throw error;
@@ -4159,19 +4120,16 @@ const createMessages = ({ stdio, all, ipcOutput, originalError, signal, signalDe
 		killSignal
 	});
 	const originalMessage = getOriginalMessage(originalError, cwd);
-	const suffix = originalMessage === void 0 ? "" : `\n${originalMessage}`;
-	const shortMessage = `${prefix}: ${escapedCommand}${suffix}`;
-	const messageStdio = all === void 0 ? [stdio[2], stdio[1]] : [all];
-	const message = [
-		shortMessage,
-		...messageStdio,
-		...stdio.slice(3),
-		ipcOutput.map((ipcMessage) => serializeIpcMessage(ipcMessage)).join("\n")
-	].map((messagePart) => escapeLines(stripFinalNewline(serializeMessagePart(messagePart)))).filter(Boolean).join("\n\n");
+	const shortMessage = `${prefix}: ${escapedCommand}${originalMessage === void 0 ? "" : `\n${originalMessage}`}`;
 	return {
 		originalMessage,
 		shortMessage,
-		message
+		message: [
+			shortMessage,
+			...all === void 0 ? [stdio[2], stdio[1]] : [all],
+			...stdio.slice(3),
+			ipcOutput.map((ipcMessage) => serializeIpcMessage(ipcMessage)).join("\n")
+		].map((messagePart) => escapeLines(stripFinalNewline(serializeMessagePart(messagePart)))).filter(Boolean).join("\n\n")
 	};
 };
 const getErrorPrefix = ({ originalError, timedOut, timeout, isMaxBuffer, maxBuffer, errorCode, signal, signalDescription, exitCode, isCanceled, isGracefullyCanceled, isForcefullyTerminated, forceKillAfterDelay, killSignal }) => {
@@ -4192,8 +4150,7 @@ const getErrorPrefix = ({ originalError, timedOut, timeout, isMaxBuffer, maxBuff
 const getForcefulSuffix = (isForcefullyTerminated, forceKillAfterDelay) => isForcefullyTerminated ? ` and was forcefully terminated after ${forceKillAfterDelay} milliseconds` : "";
 const getOriginalMessage = (originalError, cwd) => {
 	if (originalError instanceof DiscardedError) return;
-	const originalMessage = isExecaError(originalError) ? originalError.originalMessage : String(originalError?.message ?? originalError);
-	const escapedOriginalMessage = escapeLines(fixCwdError(originalMessage, cwd));
+	const escapedOriginalMessage = escapeLines(fixCwdError(isExecaError(originalError) ? originalError.originalMessage : String(originalError?.message ?? originalError), cwd));
 	return escapedOriginalMessage === "" ? void 0 : escapedOriginalMessage;
 };
 const serializeIpcMessage = (ipcMessage) => typeof ipcMessage === "string" ? ipcMessage : (0, node_util.inspect)(ipcMessage);
@@ -4315,11 +4272,10 @@ const omitUndefinedProperties = (result) => Object.fromEntries(Object.entries(re
 const normalizeExitPayload = (rawExitCode, rawSignal) => {
 	const exitCode = rawExitCode === null ? void 0 : rawExitCode;
 	const signal = rawSignal === null ? void 0 : rawSignal;
-	const signalDescription = signal === void 0 ? void 0 : getSignalDescription(rawSignal);
 	return {
 		exitCode,
 		signal,
-		signalDescription
+		signalDescription: signal === void 0 ? void 0 : getSignalDescription(rawSignal)
 	};
 };
 
@@ -4384,8 +4340,7 @@ function prettyMilliseconds(milliseconds, options) {
 	let result = [];
 	const floorDecimals = (value, decimalDigits) => {
 		const flooredInterimValue = Math.floor(value * 10 ** decimalDigits + SECOND_ROUNDING_EPSILON);
-		const flooredValue = Math.round(flooredInterimValue) / 10 ** decimalDigits;
-		return flooredValue.toFixed(decimalDigits);
+		return (Math.round(flooredInterimValue) / 10 ** decimalDigits).toFixed(decimalDigits);
 	};
 	const add = (value, long, short, valueString) => {
 		if ((result.length === 0 || !options.colonNotation) && isZero(value) && !(options.colonNotation && short === "m")) return;
@@ -4422,14 +4377,11 @@ function prettyMilliseconds(milliseconds, options) {
 		} else {
 			const millisecondsAndBelow = milliseconds$1 + microseconds / 1e3 + nanoseconds / 1e6;
 			const millisecondsDecimalDigits = typeof options.millisecondsDecimalDigits === "number" ? options.millisecondsDecimalDigits : 0;
-			const roundedMilliseconds = millisecondsAndBelow >= 1 ? Math.round(millisecondsAndBelow) : Math.ceil(millisecondsAndBelow);
-			const millisecondsString = millisecondsDecimalDigits ? millisecondsAndBelow.toFixed(millisecondsDecimalDigits) : roundedMilliseconds;
+			const millisecondsString = millisecondsDecimalDigits ? millisecondsAndBelow.toFixed(millisecondsDecimalDigits) : millisecondsAndBelow >= 1 ? Math.round(millisecondsAndBelow) : Math.ceil(millisecondsAndBelow);
 			add(Number.parseFloat(millisecondsString), "millisecond", "ms", millisecondsString);
 		}
 	} else {
-		const seconds = (isBigInt ? Number(milliseconds % ONE_DAY_IN_MILLISECONDS) : milliseconds) / 1e3 % 60;
-		const secondsDecimalDigits = typeof options.secondsDecimalDigits === "number" ? options.secondsDecimalDigits : 1;
-		const secondsFixed = floorDecimals(seconds, secondsDecimalDigits);
+		const secondsFixed = floorDecimals((isBigInt ? Number(milliseconds % ONE_DAY_IN_MILLISECONDS) : milliseconds) / 1e3 % 60, typeof options.secondsDecimalDigits === "number" ? options.secondsDecimalDigits : 1);
 		const secondsString = options.keepDecimalsOnWholeSeconds ? secondsFixed : secondsFixed.replace(/\.0+$/, "");
 		add(Number.parseFloat(secondsString), "second", "s", secondsString);
 	}
@@ -4458,10 +4410,9 @@ const logResult = (result, verboseInfo) => {
 	logDuration(result, verboseInfo);
 };
 const logDuration = (result, verboseInfo) => {
-	const verboseMessage = `(done in ${prettyMilliseconds(result.durationMs)})`;
 	verboseLog({
 		type: "duration",
-		verboseMessage,
+		verboseMessage: `(done in ${prettyMilliseconds(result.durationMs)})`,
 		verboseInfo,
 		result
 	});
@@ -4588,18 +4539,16 @@ const TYPE_TO_MESSAGE = {
 const getTransformObjectModes = (objectMode, index, newTransforms, direction) => direction === "output" ? getOutputObjectModes(objectMode, index, newTransforms) : getInputObjectModes(objectMode, index, newTransforms);
 const getOutputObjectModes = (objectMode, index, newTransforms) => {
 	const writableObjectMode = index !== 0 && newTransforms[index - 1].value.readableObjectMode;
-	const readableObjectMode = objectMode ?? writableObjectMode;
 	return {
 		writableObjectMode,
-		readableObjectMode
+		readableObjectMode: objectMode ?? writableObjectMode
 	};
 };
 const getInputObjectModes = (objectMode, index, newTransforms) => {
 	const writableObjectMode = index === 0 ? objectMode === true : newTransforms[index - 1].value.readableObjectMode;
-	const readableObjectMode = index !== newTransforms.length - 1 && (objectMode ?? writableObjectMode);
 	return {
 		writableObjectMode,
-		readableObjectMode
+		readableObjectMode: index !== newTransforms.length - 1 && (objectMode ?? writableObjectMode)
 	};
 };
 const getFdObjectMode = (stdioItems, direction) => {
@@ -4908,8 +4857,7 @@ const validateDuplicateStreamSync = ({ otherStdioItems, type, value, optionName,
 const getDuplicateStreamInstance = ({ otherStdioItems, type, value, optionName, direction }) => {
 	const duplicateStdioItems = otherStdioItems.filter((stdioItem) => hasSameValue(stdioItem, value));
 	if (duplicateStdioItems.length === 0) return;
-	const differentStdioItem = duplicateStdioItems.find((stdioItem) => stdioItem.direction !== direction);
-	throwOnDuplicateStream(differentStdioItem, optionName, type);
+	throwOnDuplicateStream(duplicateStdioItems.find((stdioItem) => stdioItem.direction !== direction), optionName, type);
 	return direction === "output" ? duplicateStdioItems[0].stream : void 0;
 };
 const hasSameValue = ({ type, value }, secondValue) => {
@@ -4918,8 +4866,7 @@ const hasSameValue = ({ type, value }, secondValue) => {
 	return value === secondValue;
 };
 const validateDuplicateTransform = ({ otherStdioItems, type, value, optionName }) => {
-	const duplicateStdioItem = otherStdioItems.find(({ value: { transform } }) => transform === value.transform);
-	throwOnDuplicateStream(duplicateStdioItem, optionName, type);
+	throwOnDuplicateStream(otherStdioItems.find(({ value: { transform } }) => transform === value.transform), optionName, type);
 };
 const throwOnDuplicateStream = (stdioItem, optionName, type) => {
 	if (stdioItem !== void 0) throw new TypeError(`The \`${stdioItem.optionName}\` and \`${optionName}\` options must not target ${TYPE_TO_MESSAGE[type]} that is the same.`);
@@ -4928,15 +4875,13 @@ const throwOnDuplicateStream = (stdioItem, optionName, type) => {
 //#endregion
 //#region ../../node_modules/.pnpm/execa@9.5.2/node_modules/execa/lib/stdio/handle.js
 const handleStdio = (addProperties$2, options, verboseInfo, isSync) => {
-	const stdio = normalizeStdioOption(options, verboseInfo, isSync);
-	const initialFileDescriptors = stdio.map((stdioOption, fdNumber) => getFileDescriptor({
-		stdioOption,
-		fdNumber,
-		options,
-		isSync
-	}));
 	const fileDescriptors = getFinalFileDescriptors({
-		initialFileDescriptors,
+		initialFileDescriptors: normalizeStdioOption(options, verboseInfo, isSync).map((stdioOption, fdNumber) => getFileDescriptor({
+			stdioOption,
+			fdNumber,
+			options,
+			isSync
+		})),
 		addProperties: addProperties$2,
 		options,
 		isSync
@@ -4953,14 +4898,13 @@ const getFileDescriptor = ({ stdioOption, fdNumber, options, isSync }) => {
 		optionName
 	});
 	const direction = getStreamDirection(initialStdioItems, fdNumber, optionName);
-	const stdioItems = initialStdioItems.map((stdioItem) => handleNativeStream({
+	const normalizedStdioItems = normalizeTransforms(initialStdioItems.map((stdioItem) => handleNativeStream({
 		stdioItem,
 		isStdioArray,
 		fdNumber,
 		direction,
 		isSync
-	}));
-	const normalizedStdioItems = normalizeTransforms(stdioItems, optionName, direction, options);
+	})), optionName, direction, options);
 	const objectMode = getFdObjectMode(normalizedStdioItems, direction);
 	validateFileObjectMode(normalizedStdioItems, objectMode);
 	return {
@@ -4970,9 +4914,7 @@ const getFileDescriptor = ({ stdioOption, fdNumber, options, isSync }) => {
 	};
 };
 const initializeStdioItems = ({ stdioOption, fdNumber, options, optionName }) => {
-	const values = Array.isArray(stdioOption) ? stdioOption : [stdioOption];
-	const initialStdioItems = [...values.map((value) => initializeStdioItem(value, optionName)), ...handleInputOptions(options, fdNumber)];
-	const stdioItems = filterDuplicates(initialStdioItems);
+	const stdioItems = filterDuplicates([...(Array.isArray(stdioOption) ? stdioOption : [stdioOption]).map((value) => initializeStdioItem(value, optionName)), ...handleInputOptions(options, fdNumber)]);
 	const isStdioArray = stdioItems.length > 1;
 	validateStdioArray(stdioItems, isStdioArray, optionName);
 	validateStreams(stdioItems);
@@ -5022,18 +4964,17 @@ const getFinalFileDescriptors = ({ initialFileDescriptors, addProperties: addPro
 	}
 };
 const getFinalFileDescriptor = ({ fileDescriptor: { direction, objectMode, stdioItems }, fileDescriptors, addProperties: addProperties$2, options, isSync }) => {
-	const finalStdioItems = stdioItems.map((stdioItem) => addStreamProperties({
-		stdioItem,
-		addProperties: addProperties$2,
-		direction,
-		options,
-		fileDescriptors,
-		isSync
-	}));
 	return {
 		direction,
 		objectMode,
-		stdioItems: finalStdioItems
+		stdioItems: stdioItems.map((stdioItem) => addStreamProperties({
+			stdioItem,
+			addProperties: addProperties$2,
+			direction,
+			options,
+			fileDescriptors,
+			isSync
+		}))
 	};
 };
 const addStreamProperties = ({ stdioItem, addProperties: addProperties$2, direction, options, fileDescriptors, isSync }) => {
@@ -5163,8 +5104,7 @@ const appendNewlineGenerator = function* ({ isWindowsNewline = false }, chunk) {
 		yield chunk;
 		return;
 	}
-	const newline = isWindowsNewline ? windowsNewline : unixNewline;
-	yield concatBytes(chunk, newline);
+	yield concatBytes(chunk, isWindowsNewline ? windowsNewline : unixNewline);
 };
 const concatString = (firstChunk, secondChunk) => `${firstChunk}${secondChunk}`;
 const linesStringInfo = {
@@ -5309,7 +5249,7 @@ const generatorToStream = ({ value, value: { transform, final, writableObjectMod
 	const transformMethod = transformAsync ? pushChunks.bind(void 0, transformChunk, state) : pushChunksSync.bind(void 0, transformChunkSync);
 	const finalMethod = transformAsync || finalAsync ? pushChunks.bind(void 0, finalChunks, state) : pushChunksSync.bind(void 0, finalChunksSync);
 	const destroyMethod = transformAsync || finalAsync ? destroyTransform.bind(void 0, state) : void 0;
-	const stream = new node_stream.Transform({
+	return { stream: new node_stream.Transform({
 		writableObjectMode,
 		writableHighWaterMark: (0, node_stream.getDefaultHighWaterMark)(writableObjectMode),
 		readableObjectMode,
@@ -5325,16 +5265,12 @@ const generatorToStream = ({ value, value: { transform, final, writableObjectMod
 			finalMethod([generators], this, done);
 		},
 		destroy: destroyMethod
-	});
-	return { stream };
+	}) };
 };
 const runGeneratorsSync = (chunks, stdioItems, encoding, isInput) => {
 	const generators = stdioItems.filter(({ type }) => type === "generator");
 	const reversedGenerators = isInput ? generators.reverse() : generators;
-	for (const { value, optionName } of reversedGenerators) {
-		const generators$1 = addInternalGenerators(value, encoding, optionName);
-		chunks = runTransformSync(generators$1, chunks);
-	}
+	for (const { value, optionName } of reversedGenerators) chunks = runTransformSync(addInternalGenerators(value, encoding, optionName), chunks);
 	return chunks;
 };
 const addInternalGenerators = ({ transform, final, binary, writableObjectMode, readableObjectMode, preserveNewlines }, encoding, optionName) => {
@@ -5371,9 +5307,7 @@ const addInputOptionSync = (fileDescriptors, fdNumber, options) => {
 		const [{ type, optionName }] = allStdioItems;
 		throw new TypeError(`Only the \`stdin\` option, not \`${optionName}\`, can be ${TYPE_TO_MESSAGE[type]} with synchronous methods.`);
 	}
-	const allContents = allStdioItems.map(({ contents }) => contents);
-	const transformedContents = allContents.map((contents) => applySingleInputGeneratorsSync(contents, stdioItems));
-	options.input = joinToUint8Array(transformedContents);
+	options.input = joinToUint8Array(allStdioItems.map(({ contents }) => contents).map((contents) => applySingleInputGeneratorsSync(contents, stdioItems)));
 };
 const applySingleInputGeneratorsSync = (contents, stdioItems) => {
 	const newContents = runGeneratorsSync(contents, stdioItems, "utf8", true);
@@ -5398,10 +5332,9 @@ const logLinesSync = (linesArray, fdNumber, verboseInfo) => {
 };
 const isPipingStream = (stream) => stream._readableState.pipes.length > 0;
 const logLine = (line, fdNumber, verboseInfo) => {
-	const verboseMessage = serializeVerboseMessage(line);
 	verboseLog({
 		type: "output",
-		verboseMessage,
+		verboseMessage: serializeVerboseMessage(line),
 		fdNumber,
 		verboseInfo
 	});
@@ -5413,28 +5346,25 @@ const transformOutputSync = ({ fileDescriptors, syncResult: { output }, options,
 	if (output === null) return { output: Array.from({ length: 3 }) };
 	const state = {};
 	const outputFiles = /* @__PURE__ */ new Set([]);
-	const transformedOutput = output.map((result, fdNumber) => transformOutputResultSync({
-		result,
-		fileDescriptors,
-		fdNumber,
-		state,
-		outputFiles,
-		isMaxBuffer,
-		verboseInfo
-	}, options));
 	return {
-		output: transformedOutput,
+		output: output.map((result, fdNumber) => transformOutputResultSync({
+			result,
+			fileDescriptors,
+			fdNumber,
+			state,
+			outputFiles,
+			isMaxBuffer,
+			verboseInfo
+		}, options)),
 		...state
 	};
 };
 const transformOutputResultSync = ({ result, fileDescriptors, fdNumber, state, outputFiles, isMaxBuffer, verboseInfo }, { buffer, encoding, lines, stripFinalNewline: stripFinalNewline$1, maxBuffer }) => {
 	if (result === null) return;
-	const truncatedResult = truncateMaxBufferSync(result, isMaxBuffer, maxBuffer);
-	const uint8ArrayResult = bufferToUint8Array(truncatedResult);
+	const uint8ArrayResult = bufferToUint8Array(truncateMaxBufferSync(result, isMaxBuffer, maxBuffer));
 	const { stdioItems, objectMode } = fileDescriptors[fdNumber];
-	const chunks = runOutputGeneratorsSync([uint8ArrayResult], stdioItems, encoding, state);
 	const { serializedResult, finalResult = serializedResult } = serializeChunks({
-		chunks,
+		chunks: runOutputGeneratorsSync([uint8ArrayResult], stdioItems, encoding, state),
 		objectMode,
 		encoding,
 		lines,
@@ -5545,14 +5475,12 @@ const isFailedExit = (exitCode, signal) => exitCode !== 0 || signal !== null;
 //#region ../../node_modules/.pnpm/execa@9.5.2/node_modules/execa/lib/resolve/exit-sync.js
 const getExitResultSync = ({ error, status: exitCode, signal, output }, { maxBuffer }) => {
 	const resultError = getResultError(error, exitCode, signal);
-	const timedOut = resultError?.code === "ETIMEDOUT";
-	const isMaxBuffer = isMaxBufferSync(resultError, output, maxBuffer);
 	return {
 		resultError,
 		exitCode,
 		signal,
-		timedOut,
-		isMaxBuffer
+		timedOut: resultError?.code === "ETIMEDOUT",
+		isMaxBuffer: isMaxBufferSync(resultError, output, maxBuffer)
 	};
 };
 const getResultError = (error, exitCode, signal) => {
@@ -5564,7 +5492,7 @@ const getResultError = (error, exitCode, signal) => {
 //#region ../../node_modules/.pnpm/execa@9.5.2/node_modules/execa/lib/methods/main-sync.js
 const execaCoreSync = (rawFile, rawArguments, rawOptions) => {
 	const { file, commandArguments, command, escapedCommand, startTime, verboseInfo, options, fileDescriptors } = handleSyncArguments(rawFile, rawArguments, rawOptions);
-	const result = spawnSubprocessSync({
+	return handleResult(spawnSubprocessSync({
 		file,
 		commandArguments,
 		options,
@@ -5573,15 +5501,12 @@ const execaCoreSync = (rawFile, rawArguments, rawOptions) => {
 		verboseInfo,
 		fileDescriptors,
 		startTime
-	});
-	return handleResult(result, verboseInfo, options);
+	}), verboseInfo, options);
 };
 const handleSyncArguments = (rawFile, rawArguments, rawOptions) => {
 	const { command, escapedCommand, startTime, verboseInfo } = handleCommand(rawFile, rawArguments, rawOptions);
-	const syncOptions = normalizeSyncOptions(rawOptions);
-	const { file, commandArguments, options } = normalizeOptions(rawFile, rawArguments, syncOptions);
+	const { file, commandArguments, options } = normalizeOptions(rawFile, rawArguments, normalizeSyncOptions(rawOptions));
 	validateSyncOptions(options);
-	const fileDescriptors = handleStdioSync(options, verboseInfo);
 	return {
 		file,
 		commandArguments,
@@ -5590,7 +5515,7 @@ const handleSyncArguments = (rawFile, rawArguments, rawOptions) => {
 		startTime,
 		verboseInfo,
 		options,
-		fileDescriptors
+		fileDescriptors: handleStdioSync(options, verboseInfo)
 	};
 };
 const normalizeSyncOptions = (options) => options.node && !options.ipc ? {
@@ -5625,16 +5550,14 @@ const spawnSubprocessSync = ({ file, commandArguments, options, command, escaped
 		isMaxBuffer,
 		verboseInfo
 	});
-	const stdio = output.map((stdioOutput, fdNumber) => stripNewline(stdioOutput, options, fdNumber));
-	const all = stripNewline(getAllSync(output, options), options, "all");
 	return getSyncResult({
 		error,
 		exitCode,
 		signal,
 		timedOut,
 		isMaxBuffer,
-		stdio,
-		all,
+		stdio: output.map((stdioOutput, fdNumber) => stripNewline(stdioOutput, options, fdNumber)),
+		all: stripNewline(getAllSync(output, options), options, "all"),
 		options,
 		command,
 		escapedCommand,
@@ -5644,8 +5567,7 @@ const spawnSubprocessSync = ({ file, commandArguments, options, command, escaped
 const runSubprocessSync = ({ file, commandArguments, options, command, escapedCommand, fileDescriptors, startTime }) => {
 	try {
 		addInputOptionsSync(fileDescriptors, options);
-		const normalizedOptions = normalizeSpawnSyncOptions(options);
-		return (0, node_child_process.spawnSync)(file, commandArguments, normalizedOptions);
+		return (0, node_child_process.spawnSync)(file, commandArguments, normalizeSpawnSyncOptions(options));
 	} catch (error) {
 		return makeEarlyError({
 			error,
@@ -5863,19 +5785,17 @@ const handleEarlyError = ({ error, command, escapedCommand, fileDescriptors, opt
 		writable,
 		duplex
 	});
-	const earlyError = makeEarlyError({
-		error,
-		command,
-		escapedCommand,
-		fileDescriptors,
-		options,
-		startTime,
-		isSync: false
-	});
-	const promise = handleDummyPromise(earlyError, verboseInfo, options);
 	return {
 		subprocess,
-		promise
+		promise: handleDummyPromise(makeEarlyError({
+			error,
+			command,
+			escapedCommand,
+			fileDescriptors,
+			options,
+			startTime,
+			isSync: false
+		}), verboseInfo, options)
 	};
 };
 const createDummyStreams = (subprocess, fileDescriptors) => {
@@ -5924,8 +5844,7 @@ const addProperties = {
 	nodeStream: ({ value }) => ({ stream: value }),
 	webTransform({ value: { transform, writableObjectMode, readableObjectMode } }) {
 		const objectMode = writableObjectMode || readableObjectMode;
-		const stream = node_stream.Duplex.fromWeb(transform, { objectMode });
-		return { stream };
+		return { stream: node_stream.Duplex.fromWeb(transform, { objectMode }) };
 	},
 	duplex: ({ value: { transform } }) => ({ stream: transform }),
 	native() {}
@@ -6171,10 +6090,7 @@ const pipeOutputAsync = (subprocess, fileDescriptors, controller) => {
 			controller
 		});
 	}
-	for (const [outputStream, inputStreams] of pipeGroups.entries()) {
-		const inputStream = inputStreams.length === 1 ? inputStreams[0] : mergeStreams(inputStreams);
-		pipeStreams(inputStream, outputStream);
-	}
+	for (const [outputStream, inputStreams] of pipeGroups.entries()) pipeStreams(inputStreams.length === 1 ? inputStreams[0] : mergeStreams(inputStreams), outputStream);
 };
 const pipeTransform = (subprocess, stream, direction, fdNumber) => {
 	if (direction === "output") pipeStreams(subprocess.stdio[fdNumber], stream);
@@ -6436,10 +6352,9 @@ const normalizePipeArguments = ({ source, sourcePromise, boundOptions, createNes
 const getDestinationStream = (boundOptions, createNested, pipeArguments) => {
 	try {
 		const { destination, pipeOptions: { from, to, unpipeSignal } = {} } = getDestination(boundOptions, createNested, ...pipeArguments);
-		const destinationStream = getToStream(destination, to);
 		return {
 			destination,
-			destinationStream,
+			destinationStream: getToStream(destination, to),
 			from,
 			unpipeSignal
 		};
@@ -6448,19 +6363,15 @@ const getDestinationStream = (boundOptions, createNested, pipeArguments) => {
 	}
 };
 const getDestination = (boundOptions, createNested, firstArgument, ...pipeArguments) => {
-	if (Array.isArray(firstArgument)) {
-		const destination = createNested(mapDestinationArguments, boundOptions)(firstArgument, ...pipeArguments);
-		return {
-			destination,
-			pipeOptions: boundOptions
-		};
-	}
+	if (Array.isArray(firstArgument)) return {
+		destination: createNested(mapDestinationArguments, boundOptions)(firstArgument, ...pipeArguments),
+		pipeOptions: boundOptions
+	};
 	if (typeof firstArgument === "string" || firstArgument instanceof URL || isDenoExecPath(firstArgument)) {
 		if (Object.keys(boundOptions).length > 0) throw new TypeError("Please use .pipe(\"file\", ..., options) or .pipe(execa(\"file\", ..., options)) instead of .pipe(options)(\"file\", ...).");
 		const [rawFile, rawArguments, rawOptions] = normalizeParameters(firstArgument, ...pipeArguments);
-		const destination = createNested(mapDestinationArguments)(rawFile, rawArguments, rawOptions);
 		return {
-			destination,
+			destination: createNested(mapDestinationArguments)(rawFile, rawArguments, rawOptions),
 			pipeOptions: rawOptions
 		};
 	}
@@ -6480,8 +6391,7 @@ const mapDestinationArguments = ({ options }) => ({ options: {
 } });
 const getSourceStream = (source, from) => {
 	try {
-		const sourceStream = getFromStream(source, from);
-		return { sourceStream };
+		return { sourceStream: getFromStream(source, from) };
 	} catch (error) {
 		return { sourceError: error };
 	}
@@ -6575,9 +6485,8 @@ const unpipeOnAbort = (unpipeSignal, unpipeContext) => unpipeSignal === void 0 ?
 const unpipeOnSignalAbort = async (unpipeSignal, { sourceStream, mergedStream, fileDescriptors, sourceOptions, startTime }) => {
 	await (0, node_util.aborted)(unpipeSignal, sourceStream);
 	await mergedStream.remove(sourceStream);
-	const error = /* @__PURE__ */ new Error("Pipe canceled by `unpipeSignal` option.");
 	throw createNonCommandError({
-		error,
+		error: /* @__PURE__ */ new Error("Pipe canceled by `unpipeSignal` option."),
 		fileDescriptors,
 		sourceOptions,
 		startTime
@@ -6680,13 +6589,12 @@ const stopReadingOnStreamEnd = async (onStreamEnd, controller, stream) => {
 	}
 };
 const iterateOnStream = ({ stream, controller, binary, shouldEncode, encoding, shouldSplit, preserveNewlines }) => {
-	const onStdoutChunk = (0, node_events.on)(stream, "data", {
-		signal: controller.signal,
-		highWaterMark: HIGH_WATER_MARK,
-		highWatermark: HIGH_WATER_MARK
-	});
 	return iterateOnData({
-		onStdoutChunk,
+		onStdoutChunk: (0, node_events.on)(stream, "data", {
+			signal: controller.signal,
+			highWaterMark: HIGH_WATER_MARK,
+			highWatermark: HIGH_WATER_MARK
+		}),
 		controller,
 		binary,
 		shouldEncode,
@@ -6731,13 +6639,12 @@ const getStreamOutput = async ({ stream, onStreamEnd, fdNumber, encoding, buffer
 		await Promise.all([resumeStream(stream), logPromise]);
 		return;
 	}
-	const stripFinalNewlineValue = getStripFinalNewline(stripFinalNewline$1, fdNumber);
 	const iterable = iterateForResult({
 		stream,
 		onStreamEnd,
 		lines,
 		encoding,
-		stripFinalNewline: stripFinalNewlineValue,
+		stripFinalNewline: getStripFinalNewline(stripFinalNewline$1, fdNumber),
 		allMixed
 	});
 	const [output] = await Promise.all([getStreamContents({
@@ -6757,15 +6664,14 @@ const logOutputAsync = async ({ stream, onStreamEnd, fdNumber, encoding, allMixe
 		verboseInfo,
 		fdNumber
 	})) return;
-	const linesIterable = iterateForResult({
+	await logLines(iterateForResult({
 		stream,
 		onStreamEnd,
 		lines: true,
 		encoding,
 		stripFinalNewline: true,
 		allMixed
-	});
-	await logLines(linesIterable, stream, fdNumber, verboseInfo);
+	}), stream, fdNumber, verboseInfo);
 };
 const resumeStream = async (stream) => {
 	await (0, node_timers_promises.setImmediate)();
@@ -6915,10 +6821,9 @@ const getAllMixed = ({ all, stdout, stderr }) => all && stdout && stderr && stdo
 //#region ../../node_modules/.pnpm/execa@9.5.2/node_modules/execa/lib/verbose/ipc.js
 const shouldLogIpc = (verboseInfo) => isFullVerbose(verboseInfo, "ipc");
 const logIpcOutput = (message, verboseInfo) => {
-	const verboseMessage = serializeVerboseMessage(message);
 	verboseLog({
 		type: "ipc",
-		verboseMessage,
+		verboseMessage: serializeVerboseMessage(message),
 		fdNumber: "ipc",
 		verboseInfo
 	});
@@ -7061,9 +6966,8 @@ const addConcurrentStream = (concurrentStreams, stream, waitName) => {
 	const promises = weakMap.get(stream);
 	const promise = createDeferred();
 	promises.push(promise);
-	const resolve = promise.resolve.bind(promise);
 	return {
-		resolve,
+		resolve: promise.resolve.bind(promise),
 		promises
 	};
 };
@@ -7144,10 +7048,9 @@ const createReadable = ({ subprocess, concurrentStreams, encoding }, { from, bin
 };
 const getSubprocessStdout = (subprocess, from, concurrentStreams) => {
 	const subprocessStdout = getFromStream(subprocess, from);
-	const waitReadableDestroy = addConcurrentStream(concurrentStreams, subprocessStdout, "readableDestroy");
 	return {
 		subprocessStdout,
-		waitReadableDestroy
+		waitReadableDestroy: addConcurrentStream(concurrentStreams, subprocessStdout, "readableDestroy")
 	};
 };
 const getReadableOptions = ({ readableEncoding, readableObjectMode, readableHighWaterMark }, binary) => binary ? {
@@ -7225,12 +7128,10 @@ const createWritable = ({ subprocess, concurrentStreams }, { to } = {}) => {
 };
 const getSubprocessStdin = (subprocess, to, concurrentStreams) => {
 	const subprocessStdin = getToStream(subprocess, to);
-	const waitWritableFinal = addConcurrentStream(concurrentStreams, subprocessStdin, "writableFinal");
-	const waitWritableDestroy = addConcurrentStream(concurrentStreams, subprocessStdin, "writableDestroy");
 	return {
 		subprocessStdin,
-		waitWritableFinal,
-		waitWritableDestroy
+		waitWritableFinal: addConcurrentStream(concurrentStreams, subprocessStdin, "writableFinal"),
+		waitWritableDestroy: addConcurrentStream(concurrentStreams, subprocessStdin, "writableDestroy")
 	};
 };
 const getWritableMethods = (subprocessStdin, subprocess, waitWritableFinal) => ({
@@ -7326,15 +7227,14 @@ const onDuplexDestroy = async ({ subprocessStdout, subprocessStdin, subprocess,
 const createIterable = (subprocess, encoding, { from, binary: binaryOption = false, preserveNewlines = false } = {}) => {
 	const binary = binaryOption || BINARY_ENCODINGS.has(encoding);
 	const subprocessStdout = getFromStream(subprocess, from);
-	const onStdoutData = iterateOnSubprocessStream({
+	return iterateOnStdoutData(iterateOnSubprocessStream({
 		subprocessStdout,
 		subprocess,
 		binary,
 		shouldEncode: true,
 		encoding,
 		preserveNewlines
-	});
-	return iterateOnStdoutData(onStdoutData, subprocessStdout, subprocess);
+	}), subprocessStdout, subprocess);
 };
 const iterateOnStdoutData = async function* (onStdoutData, subprocessStdout, subprocess) {
 	try {
@@ -7416,7 +7316,6 @@ const handleAsyncArguments = (rawFile, rawArguments, rawOptions) => {
 	const { command, escapedCommand, startTime, verboseInfo } = handleCommand(rawFile, rawArguments, rawOptions);
 	const { file, commandArguments, options: normalizedOptions } = normalizeOptions(rawFile, rawArguments, rawOptions);
 	const options = handleAsyncOptions(normalizedOptions);
-	const fileDescriptors = handleStdioAsync(options, verboseInfo);
 	return {
 		file,
 		commandArguments,
@@ -7425,7 +7324,7 @@ const handleAsyncArguments = (rawFile, rawArguments, rawOptions) => {
 		startTime,
 		verboseInfo,
 		options,
-		fileDescriptors
+		fileDescriptors: handleStdioAsync(options, verboseInfo)
 	};
 };
 const handleAsyncOptions = ({ timeout, signal,...options }) => {
@@ -7498,22 +7397,19 @@ const handlePromise = async ({ subprocess, options, startTime, verboseInfo, file
 	});
 	controller.abort();
 	onInternalError.resolve();
-	const stdio = stdioResults.map((stdioResult, fdNumber) => stripNewline(stdioResult, options, fdNumber));
-	const all = stripNewline(allResult, options, "all");
-	const result = getAsyncResult({
+	return handleResult(getAsyncResult({
 		errorInfo,
 		exitCode,
 		signal,
-		stdio,
-		all,
+		stdio: stdioResults.map((stdioResult, fdNumber) => stripNewline(stdioResult, options, fdNumber)),
+		all: stripNewline(allResult, options, "all"),
 		ipcOutput,
 		context,
 		options,
 		command,
 		escapedCommand,
 		startTime
-	});
-	return handleResult(result, verboseInfo, options);
+	}), verboseInfo, options);
 };
 const getAsyncResult = ({ errorInfo, exitCode, signal, stdio, all, ipcOutput, context, options, command, escapedCommand, startTime }) => "error" in errorInfo ? makeError({
 	error: errorInfo.error,
@@ -7586,8 +7482,7 @@ const callBoundExeca = ({ mapArguments, deepOptions = {}, boundOptions = {}, set
 	return isSync ? execaCoreSync(file, commandArguments, options) : execaCoreAsync(file, commandArguments, options, createNested);
 };
 const parseArguments = ({ mapArguments, firstArgument, nextArguments, deepOptions, boundOptions }) => {
-	const callArguments = isTemplateString(firstArgument) ? parseTemplates(firstArgument, nextArguments) : [firstArgument, ...nextArguments];
-	const [initialFile, initialArguments, initialOptions] = normalizeParameters(...callArguments);
+	const [initialFile, initialArguments, initialOptions] = normalizeParameters(...isTemplateString(firstArgument) ? parseTemplates(firstArgument, nextArguments) : [firstArgument, ...nextArguments]);
 	const mergedOptions = mergeOptions(mergeOptions(deepOptions, boundOptions), initialOptions);
 	const { file = initialFile, commandArguments = initialArguments, options = mergedOptions, isSync = false } = mapArguments({
 		file: initialFile,
@@ -7693,8 +7588,7 @@ function delay(ms, { signal } = {}) {
 function isPlainObject(value) {
 	if (!value || typeof value !== "object") return false;
 	const proto = Object.getPrototypeOf(value);
-	const hasObjectPrototype = proto === null || proto === Object.prototype || Object.getPrototypeOf(proto) === null;
-	if (!hasObjectPrototype) return false;
+	if (!(proto === null || proto === Object.prototype || Object.getPrototypeOf(proto) === null)) return false;
 	return Object.prototype.toString.call(value) === "[object Object]";
 }
 
@@ -7741,8 +7635,7 @@ var CloudFrontManager = class {
 			region: this.region,
 			credentials: this.credentials
 		});
-		const listKgResp = await cloudfrontClient.listKeyGroups({});
-		const existingKeyGroup = listKgResp.KeyGroupList?.Items?.find((kg) => kg.KeyGroup?.KeyGroupConfig?.Name?.startsWith(`HotUpdaterKeyGroup-${publicKeyHash}`));
+		const existingKeyGroup = (await cloudfrontClient.listKeyGroups({})).KeyGroupList?.Items?.find((kg) => kg.KeyGroup?.KeyGroupConfig?.Name?.startsWith(`HotUpdaterKeyGroup-${publicKeyHash}`));
 		const existingPublicKeyId = existingKeyGroup?.KeyGroup?.KeyGroupConfig?.Items?.[0];
 		const existingKeyGroupId = existingKeyGroup?.KeyGroup?.Id;
 		if (existingPublicKeyId && existingKeyGroupId) return {
@@ -7756,8 +7649,7 @@ var CloudFrontManager = class {
 			EncodedKey: publicKey,
 			Comment: "HotUpdater public key for signed URL"
 		};
-		const createPubKeyResp = await cloudfrontClient.createPublicKey({ PublicKeyConfig: publicKeyConfig });
-		const publicKeyId = createPubKeyResp.PublicKey?.Id;
+		const publicKeyId = (await cloudfrontClient.createPublicKey({ PublicKeyConfig: publicKeyConfig })).PublicKey?.Id;
 		if (!publicKeyId) throw new Error("Failed to create CloudFront public key");
 		const callerReferenceKg = `HotUpdaterKeyGroup-${publicKeyHash}`;
 		const keyGroupConfig = {
@@ -7766,8 +7658,7 @@ var CloudFrontManager = class {
 			Comment: "HotUpdater key group for signed URL",
 			Items: [publicKeyId]
 		};
-		const createKgResp = await cloudfrontClient.createKeyGroup({ KeyGroupConfig: keyGroupConfig });
-		const keyGroupId = createKgResp.KeyGroup?.Id;
+		const keyGroupId = (await cloudfrontClient.createKeyGroup({ KeyGroupConfig: keyGroupConfig })).KeyGroup?.Id;
 		if (!keyGroupId) throw new Error("Failed to create Key Group");
 		f.success(`Created new Key Group: ${keyGroupConfig.Name}`);
 		return {
@@ -7781,37 +7672,28 @@ var CloudFrontManager = class {
 			credentials: this.credentials
 		});
 		let oacId;
-		const accountId = options.functionArn.split(":")[4];
-		if (!accountId) throw new Error("Failed to get AWS account ID");
+		if (!options.functionArn.split(":")[4]) throw new Error("Failed to get AWS account ID");
 		try {
-			const listOacResp = await cloudfrontClient.listOriginAccessControls({});
-			const existingOac = listOacResp.OriginAccessControlList?.Items?.find((oac) => oac.Name === "HotUpdaterOAC");
+			const existingOac = (await cloudfrontClient.listOriginAccessControls({})).OriginAccessControlList?.Items?.find((oac) => oac.Name === "HotUpdaterOAC");
 			if (existingOac?.Id) oacId = existingOac.Id;
-			else {
-				const createOacResp = await cloudfrontClient.createOriginAccessControl({ OriginAccessControlConfig: {
-					Name: "HotUpdaterOAC",
-					OriginAccessControlOriginType: "s3",
-					SigningBehavior: "always",
-					SigningProtocol: "sigv4"
-				} });
-				oacId = createOacResp.OriginAccessControl?.Id;
-			}
-		} catch (error) {
+			else oacId = (await cloudfrontClient.createOriginAccessControl({ OriginAccessControlConfig: {
+				Name: "HotUpdaterOAC",
+				OriginAccessControlOriginType: "s3",
+				SigningBehavior: "always",
+				SigningProtocol: "sigv4"
+			} })).OriginAccessControl?.Id;
+		} catch {
 			throw new Error("Failed to get or create Origin Access Control");
 		}
 		if (!oacId) throw new Error("Failed to get Origin Access Control ID");
 		const bucketDomain = `${options.bucketName}.s3.${this.region}.amazonaws.com`;
 		const matchingDistributions = [];
 		try {
-			const listResp = await cloudfrontClient.listDistributions({});
-			const items = listResp.DistributionList?.Items || [];
-			for (const dist of items) {
-				const origins = dist.Origins?.Items || [];
-				if (origins.some((origin) => origin.DomainName === bucketDomain)) matchingDistributions.push({
-					Id: dist.Id,
-					DomainName: dist.DomainName
-				});
-			}
+			const items = (await cloudfrontClient.listDistributions({})).DistributionList?.Items || [];
+			for (const dist of items) if ((dist.Origins?.Items || []).some((origin) => origin.DomainName === bucketDomain)) matchingDistributions.push({
+				Id: dist.Id,
+				DomainName: dist.DomainName
+			});
 		} catch (error) {
 			console.error("Error listing CloudFront distributions:", error);
 		}
@@ -8133,10 +8015,9 @@ var CloudFrontManager = class {
 				title: "Waiting for CloudFront distribution to complete...",
 				task: async (message) => {
 					while (retryCount < 600) try {
-						const status = await cloudfrontClient.getDistribution({ Id: distributionId });
-						if (status.Distribution?.Status === "Deployed") return "CloudFront distribution deployment completed.";
+						if ((await cloudfrontClient.getDistribution({ Id: distributionId })).Distribution?.Status === "Deployed") return "CloudFront distribution deployment completed.";
 						throw new Error("Retry");
-					} catch (err) {
+					} catch (_err) {
 						if (retryCount++ >= 5) message(`CloudFront distribution is still in progress. This may take a few minutes. (${retryCount})`);
 						await delay(1e3);
 					}
@@ -8184,14 +8065,13 @@ var IAMManager = class {
 				f.info(`Using existing IAM role: ${roleName} (${existingRole.Arn})`);
 				return existingRole.Arn;
 			}
-		} catch (error) {
+		} catch {
 			try {
-				const createRoleResp = await iamClient.createRole({
+				const lambdaRoleArn = (await iamClient.createRole({
 					RoleName: roleName,
 					AssumeRolePolicyDocument: assumeRolePolicyDocument,
 					Description: "Role for Lambda@Edge to access S3"
-				});
-				const lambdaRoleArn = createRoleResp.Role?.Arn;
+				})).Role?.Arn;
 				f.info(`Created IAM role: ${roleName} (${lambdaRoleArn})`);
 				await iamClient.attachRolePolicy({
 					RoleName: roleName,
@@ -8228,8 +8108,7 @@ var LambdaEdgeDeployer = class {
 		});
 		if (BD(lambdaName)) process.exit(1);
 		const lambdaPath = require.resolve("@hot-updater/aws/lambda");
-		const lambdaDir = path.default.dirname(lambdaPath);
-		const { tmpDir, removeTmpDir } = await (0, __hot_updater_plugin_core.copyDirToTmp)(lambdaDir);
+		const { tmpDir, removeTmpDir } = await (0, __hot_updater_plugin_core.copyDirToTmp)(path.default.dirname(lambdaPath));
 		const indexPath = path.default.join(tmpDir, "index.cjs");
 		const code = (0, __hot_updater_plugin_core.transformEnv)(indexPath, {
 			CLOUDFRONT_KEY_PAIR_ID: keyPair.publicKey,
@@ -8255,7 +8134,7 @@ var LambdaEdgeDeployer = class {
 							targetDir: tmpDir
 						});
 						return "Compressed Lambda code to zip";
-					} catch (error) {
+					} catch {
 						throw new Error("Failed to create zip archive of Lambda function code");
 					}
 				}
@@ -8357,7 +8236,7 @@ var S3Migration = class {
 	backupMapping = /* @__PURE__ */ new Map();
 	async doUpdateFile(key, content, { cacheControl } = {}) {
 		const normalizedKey = key.startsWith("/") ? key.substring(1) : key;
-		const upload = new __aws_sdk_lib_storage.Upload({
+		await new __aws_sdk_lib_storage.Upload({
 			client: this.s3,
 			params: {
 				Bucket: this.bucketName,
@@ -8365,12 +8244,11 @@ var S3Migration = class {
 				Body: content,
 				CacheControl: cacheControl
 			}
-		});
-		await upload.done();
+		}).done();
 	}
 	async getKeys(prefix) {
 		const keys = [];
-		let continuationToken = void 0;
+		let continuationToken;
 		do {
 			const command = new __aws_sdk_client_s3.ListObjectsV2Command({
 				Bucket: this.bucketName,
@@ -8423,8 +8301,7 @@ var S3Migration = class {
 			console.log(import_picocolors$1.default.yellow(`[DRY RUN] Updated ${import_picocolors$1.default.bold(normalizedKey)}`));
 			return;
 		}
-		const originalContent = await this.readFile(key);
-		if (originalContent !== null) await this.backupFile(key);
+		if (await this.readFile(key) !== null) await this.backupFile(key);
 		await this.doUpdateFile(normalizedKey, content, { cacheControl });
 		console.log(import_picocolors$1.default.green(`Updated ${import_picocolors$1.default.bold(normalizedKey)}`));
 	}
@@ -8528,37 +8405,32 @@ var S3Migrator = class {
 	async saveMigrationRecords(dryRun) {
 		if (dryRun) return;
 		const body = JSON.stringify(this.migrationRecords, null, 2);
-		const upload = new __aws_sdk_lib_storage.Upload({
+		await new __aws_sdk_lib_storage.Upload({
 			client: this.s3,
 			params: {
 				Bucket: this.bucketName,
 				Key: this.migrationRecordKey,
 				Body: body
 			}
-		});
-		await upload.done();
+		}).done();
 	}
 	/**
 	* Returns a JSON object containing applied and pending migrations.
 	*/
 	async list() {
 		await this.loadMigrationRecords();
-		const applied = this.migrationRecords.map((record) => ({
-			name: record.name,
-			appliedAt: record.appliedAt
-		}));
-		const pendingMigrations = this.migrations.filter((migration) => !this.migrationRecords.some((record) => record.name === migration.name));
-		const pending = pendingMigrations.map((migration) => ({ name: migration.name }));
 		return {
-			applied,
-			pending
+			applied: this.migrationRecords.map((record) => ({
+				name: record.name,
+				appliedAt: record.appliedAt
+			})),
+			pending: this.migrations.filter((migration) => !this.migrationRecords.some((record) => record.name === migration.name)).map((migration) => ({ name: migration.name }))
 		};
 	}
 	async migrate({ dryRun }) {
 		await this.loadMigrationRecords();
 		for (const migration of this.migrations) {
-			const alreadyApplied = this.migrationRecords.some((record) => record.name === migration.name);
-			if (alreadyApplied) continue;
+			if (this.migrationRecords.some((record) => record.name === migration.name)) continue;
 			console.log(import_picocolors$1.default.magenta(`Applying migration ${migration.name}...`));
 			migration.s3 = this.s3;
 			migration.bucketName = this.bucketName;
@@ -8599,8 +8471,7 @@ var Migration0001HotUpdater0_13_0 = class extends S3Migration {
 			const newKey = `production/${key}`;
 			await this.moveFile(key, newKey);
 		}
-		const productionKeys = await this.getKeys("production/");
-		const updateKeys = productionKeys.filter((key) => key.endsWith("update.json"));
+		const updateKeys = (await this.getKeys("production/")).filter((key) => key.endsWith("update.json"));
 		for (const key of updateKeys) {
 			const data = await this.readJson(key);
 			if (data && Array.isArray(data)) {
@@ -8620,8 +8491,7 @@ var Migration0001HotUpdater0_13_0 = class extends S3Migration {
 var Migration0001HotUpdater0_18_0 = class extends S3Migration {
 	name = "hot-updater_0.18.0";
 	async migrate() {
-		const keys = await this.getKeys("");
-		const updateKeys = keys.filter((key) => key.endsWith("update.json"));
+		const updateKeys = (await this.getKeys("")).filter((key) => key.endsWith("update.json"));
 		for (const key of updateKeys) {
 			const data = await this.readJson(key);
 			if (data && Array.isArray(data)) {
@@ -8685,23 +8555,20 @@ var S3Manager = class {
 			region: "us-east-1",
 			credentials: this.credentials
 		});
-		const bucketsResult = await s3Client.listBuckets({});
-		const buckets = bucketsResult.Buckets ?? [];
-		const bucketInfos = await Promise.all(buckets.filter((bucket) => bucket.Name).map(async (bucket) => {
+		const buckets = (await s3Client.listBuckets({})).Buckets ?? [];
+		return await Promise.all(buckets.filter((bucket) => bucket.Name).map(async (bucket) => {
 			const { LocationConstraint: region } = await s3Client.getBucketLocation({ Bucket: bucket.Name });
 			return {
 				name: bucket.Name,
 				region
 			};
 		}));
-		return bucketInfos;
 	}
 	async createBucket(bucketName, region) {
-		const s3Client = new __aws_sdk_client_s3.S3({
+		await new __aws_sdk_client_s3.S3({
 			region,
 			credentials: this.credentials
-		});
-		await s3Client.createBucket({
+		}).createBucket({
 			Bucket: bucketName,
 			...region === "us-east-1" ? {} : { CreateBucketConfiguration: { LocationConstraint: region } }
 		});
@@ -8780,11 +8647,10 @@ var SSMKeyPairManager = class {
 		}
 	}
 	async putParameter(name, value) {
-		const ssm = new __aws_sdk_client_ssm.SSM({
+		await new __aws_sdk_client_ssm.SSM({
 			region: this.region,
 			credentials: this.credentials
-		});
-		await ssm.putParameter({
+		}).putParameter({
 			Name: name,
 			Value: value,
 			Type: "SecureString",
@@ -8809,9 +8675,8 @@ var SSMKeyPairManager = class {
 				format: "pem"
 			}
 		});
-		const keyPairId = `HOTUPDATER-${crypto.default.randomBytes(4).toString("hex").toUpperCase()}`;
 		const keyPair = {
-			keyPairId,
+			keyPairId: `HOTUPDATER-${crypto.default.randomBytes(4).toString("hex").toUpperCase()}`,
 			publicKey,
 			privateKey
 		};
@@ -8884,17 +8749,16 @@ const checkIfAwsCliInstalled = async () => {
 	try {
 		await execa("aws", ["--version"]);
 		return true;
-	} catch (error) {
+	} catch {
 		return false;
 	}
 };
 const runInit = async ({ build }) => {
-	const isAwsCliInstalled = await checkIfAwsCliInstalled();
-	if (!isAwsCliInstalled) {
+	if (!await checkIfAwsCliInstalled()) {
 		f.error(`AWS CLI is not installed. Please visit ${(0, __hot_updater_plugin_core.link)("https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html")} for installation instructions`);
 		process.exit(1);
 	}
-	let credentials = void 0;
+	let credentials;
 	const mode = await ve({
 		message: "Select the mode to login to AWS",
 		options: [{
@@ -9005,14 +8869,11 @@ const runInit = async ({ build }) => {
 		region: bucketRegion,
 		migrations: [new Migration0001HotUpdater0_13_0(), new Migration0001HotUpdater0_18_0()]
 	});
-	const iamManager = new IAMManager(bucketRegion, credentials);
-	const lambdaRoleArn = await iamManager.createOrSelectRole();
-	const ssmKeyPairManager = new SSMKeyPairManager(bucketRegion, credentials);
-	const keyPair = await ssmKeyPairManager.getOrCreateKeyPair(`/hot-updater/${bucketName}/keypair`);
+	const lambdaRoleArn = await new IAMManager(bucketRegion, credentials).createOrSelectRole();
+	const keyPair = await new SSMKeyPairManager(bucketRegion, credentials).getOrCreateKeyPair(`/hot-updater/${bucketName}/keypair`);
 	const cloudFrontManager = new CloudFrontManager(bucketRegion, credentials);
 	const { publicKeyId, keyGroupId } = await cloudFrontManager.getOrCreateKeyGroup(keyPair.publicKey);
-	const lambdaEdgeDeployer = new LambdaEdgeDeployer(credentials);
-	const { functionArn } = await lambdaEdgeDeployer.deploy(lambdaRoleArn, {
+	const { functionArn } = await new LambdaEdgeDeployer(credentials).deploy(lambdaRoleArn, {
 		publicKey: publicKeyId,
 		privateKey: keyPair.privateKey
 	});