@hot-updater/cloudflare 1.0.0-rc.2 → 1.0.0-rc.3

package/dist/iac/index.cjs

@@ -6,7 +6,7 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __commonJSMin = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __commonJSMin = (cb, mod) => () => (mod || (cb((mod = { exports: {} }).exports, mod), cb = null), mod.exports);
 var __copyProps = (to, from, except, desc) => {
 	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
 		key = keys[i];
@@ -17,21 +17,21 @@ var __copyProps = (to, from, except, desc) => {
 	}
 	return to;
 };
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule || !__hasOwnProp.call(mod, "default") ? __defProp(target, "default", {
 	value: mod,
 	enumerable: true
 }) : target, mod));
 //#endregion
 let crypto = require("crypto");
-crypto = __toESM(crypto);
+crypto = __toESM(crypto, 1);
 let fs_promises = require("fs/promises");
-fs_promises = __toESM(fs_promises);
+fs_promises = __toESM(fs_promises, 1);
 let path = require("path");
-path = __toESM(path);
+path = __toESM(path, 1);
 let _hot_updater_cli_tools = require("@hot-updater/cli-tools");
 let _hot_updater_server = require("@hot-updater/server");
 let cloudflare = require("cloudflare");
-cloudflare = __toESM(cloudflare);
+cloudflare = __toESM(cloudflare, 1);
 let _hot_updater_plugin_core = require("@hot-updater/plugin-core");
 let _hot_updater_plugin_core_internal = require("@hot-updater/plugin-core/internal");
 let node_url = require("node:url");
@@ -39,13 +39,13 @@ let node_child_process = require("node:child_process");
 let node_string_decoder = require("node:string_decoder");
 let node_util = require("node:util");
 let node_process = require("node:process");
-node_process = __toESM(node_process);
+node_process = __toESM(node_process, 1);
 let node_tty = require("node:tty");
-node_tty = __toESM(node_tty);
+node_tty = __toESM(node_tty, 1);
 let node_path = require("node:path");
-node_path = __toESM(node_path);
+node_path = __toESM(node_path, 1);
 let fs = require("fs");
-fs = __toESM(fs);
+fs = __toESM(fs, 1);
 let node_timers_promises = require("node:timers/promises");
 let node_os = require("node:os");
 let node_events = require("node:events");
@@ -56,7 +56,7 @@ let node_stream = require("node:stream");
 let node_buffer = require("node:buffer");
 let cloudflare_error = require("cloudflare/error");
 let os = require("os");
-os = __toESM(os);
+os = __toESM(os, 1);
 //#region src/d1Rows.ts
 var InvalidD1RowError = class extends Error {
 	name = "InvalidD1RowError";
@@ -164,6 +164,29 @@ const eventRow = (row) => {
 		received_at_ms: numberValue(row, "received_at_ms", "bundle_events")
 	};
 };
+const installationRow = (row) => {
+	const type = stringValue(row, "type", "bundle_installations");
+	const platform = stringValue(row, "platform", "bundle_installations");
+	if (![
+		"UPDATE_APPLIED",
+		"RECOVERED",
+		"RELEASE_ADOPTED",
+		"UNCHANGED"
+	].includes(type) || platform !== "ios" && platform !== "android") throw new InvalidD1RowError("bundle_installations");
+	return {
+		id: stringValue(row, "id", "bundle_installations"),
+		install_id: stringValue(row, "install_id", "bundle_installations"),
+		user_id: nullableString(row, "user_id", "bundle_installations"),
+		username: nullableString(row, "username", "bundle_installations"),
+		to_bundle_id: stringValue(row, "to_bundle_id", "bundle_installations"),
+		type,
+		platform,
+		app_version: stringValue(row, "app_version", "bundle_installations"),
+		channel: stringValue(row, "channel", "bundle_installations"),
+		cohort: stringValue(row, "cohort", "bundle_installations"),
+		received_at_ms: numberValue(row, "received_at_ms", "bundle_installations")
+	};
+};
 const apiKeyRow = (row) => {
 	const role = stringValue(row, "role", "api_keys");
 	if (role !== "client") throw new InvalidD1RowError("api_keys");
@@ -238,6 +261,7 @@ function parseD1Row(model, value) {
 		case "bundle_patches": return patchRow(value);
 		case "channels": return channelRow(value);
 		case "bundle_events": return eventRow(value);
+		case "bundle_installations": return installationRow(value);
 		case "api_keys": return apiKeyRow(value);
 		case "releases": return releaseRow(value);
 		case "release_catalogs": return releaseCatalogRow(value);
@@ -274,7 +298,8 @@ const stringPredicate = (condition, operator) => {
 		};
 	}
 	const literal = escapeLikePattern(condition.value);
-	const parameter = bind(operator === "contains" ? `%${literal}%` : operator === "starts_with" ? `${literal}%` : `%${literal}`);
+	const pattern = operator === "contains" ? `%${literal}%` : operator === "starts_with" ? `${literal}%` : `%${literal}`;
+	const parameter = bind(pattern);
 	return {
 		sql: `lower(${condition.field}) LIKE lower(${parameter.sql}) ESCAPE '\\'`,
 		params: parameter.params
@@ -359,11 +384,13 @@ const d1TableNames = {
 	bundle_patches: "bundle_patches",
 	channels: "channels",
 	bundle_events: "bundle_events",
+	bundle_installations: "bundle_installations",
 	api_keys: "api_keys",
 	release_catalogs: "release_catalogs",
 	releases: "releases"
 };
 var D1QueryResultError = class extends Error {
+	result;
 	name = "D1QueryResultError";
 	operation = "count";
 	constructor(result) {
@@ -394,6 +421,7 @@ const findManyD1Rows = async (executor, input) => {
 		case "bundle_patches": return rows.map((row) => parseD1Row("bundle_patches", row));
 		case "channels": return rows.map((row) => parseD1Row("channels", row));
 		case "bundle_events": return rows.map((row) => parseD1Row("bundle_events", row));
+		case "bundle_installations": return rows.map((row) => parseD1Row("bundle_installations", row));
 		case "api_keys": return rows.map((row) => parseD1Row("api_keys", row));
 		case "releases": return rows.map((row) => parseD1Row("releases", row));
 		case "release_catalogs": return rows.map((row) => parseD1Row("release_catalogs", row));
@@ -401,6 +429,12 @@ const findManyD1Rows = async (executor, input) => {
 };
 //#endregion
 //#region src/d1Implementation.ts
+var D1ExecutionError = class extends Error {
+	name = "D1ExecutionError";
+	constructor() {
+		super("D1 did not successfully execute every requested statement");
+	}
+};
 const EXPECTATION_CONFLICT_MARKER = "HOT_UPDATER_COMMIT_EXPECTATION_CONFLICT";
 const expectationGuard = (expectations) => {
 	const clauses = [];
@@ -438,7 +472,8 @@ const expectationConflict = async (executor, expectations) => {
 		const versionField = isRelease ? "revision" : "generation";
 		const key = isRelease ? expectation.id : expectation.scopeKey;
 		const expectedVersion = isRelease ? expectation.revision : expectation.generation;
-		const actualVersion = readVersion((await executor.query(`SELECT ${versionField} FROM ${table} WHERE ${keyField} = json_extract(?, '$') LIMIT 1`, encodeD1Values([key])))[0], versionField);
+		const rows = await executor.query(`SELECT ${versionField} FROM ${table} WHERE ${keyField} = json_extract(?, '$') LIMIT 1`, encodeD1Values([key]));
+		const actualVersion = readVersion(rows[0], versionField);
 		if (actualVersion !== expectedVersion) return {
 			committed: false,
 			conflict: {
@@ -517,14 +552,14 @@ const insertQuery = (input, guard, conflictMode = "returnExisting") => {
 			values = channelValues(input.data);
 			break;
 		case "bundle_events":
+		case "bundle_installations":
 		case "api_keys":
 		case "release_catalogs":
 		case "releases":
 			columns = Object.keys(input.data);
 			values = Object.values(input.data);
-			break;
 	}
-	const conflict = input.onConflict !== "ignore" ? "" : input.model === "channels" ? conflictMode === "ignore" ? " ON CONFLICT(name) DO NOTHING" : " ON CONFLICT(name) DO UPDATE SET name = excluded.name" : input.model === "api_keys" ? conflictMode === "ignore" ? " ON CONFLICT(hash) DO NOTHING" : " ON CONFLICT(hash) DO UPDATE SET hash = excluded.hash" : "";
+	const conflict = input.onConflict !== "ignore" ? "" : input.model === "channels" ? conflictMode === "ignore" ? " ON CONFLICT(name) DO NOTHING" : " ON CONFLICT(name) DO UPDATE SET name = excluded.name" : input.model === "api_keys" ? conflictMode === "ignore" ? " ON CONFLICT(hash) DO NOTHING" : " ON CONFLICT(hash) DO UPDATE SET hash = excluded.hash" : " ON CONFLICT(install_id) DO UPDATE SET install_id = excluded.install_id";
 	return {
 		sql: `INSERT INTO ${d1TableNames[input.model]} (${columns.join(", ")}) ${guard === void 0 ? `VALUES (${d1Placeholders(values.length)})` : `SELECT ${d1Placeholders(values.length)} WHERE ${guard.sql}`}${conflict} RETURNING *`,
 		params: [...encodeD1Values(values), ...guard?.params ?? []]
@@ -588,9 +623,7 @@ const channelDeletePrecondition = (changes, changeIndex, channelId) => {
 				releaseEffects.set(change.row.id, change.row.channel_id);
 				break;
 			case "update": break;
-			case "delete":
-				releaseEffects.set(change.where.id, null);
-				break;
+			case "delete": releaseEffects.set(change.where.id, null);
 		}
 	}
 	return {
@@ -665,10 +698,6 @@ const changeQuery = (change, guard) => {
 			sql: `DELETE FROM channels WHERE id = json_extract(?, '$') AND NOT EXISTS (SELECT 1 FROM releases WHERE channel_id = json_extract(?, '$')) AND ${guard.sql}`,
 			params: [...encodeD1Values([change.where.id, change.where.id]), ...guard.params]
 		};
-		case "insights": return insertQuery({
-			model: "bundle_events",
-			data: change.row
-		}, guard);
 		case "apiKeys": return change.operation === "insert" ? insertQuery({
 			model: "api_keys",
 			data: change.row,
@@ -837,6 +866,25 @@ const deleteChannel = async (executor, input) => {
 	};
 };
 const createD1Implementation = (executor) => ({
+	async recordInsights({ event, installation }) {
+		const columns = Object.keys(installation);
+		const eventInsert = insertQuery({
+			model: "bundle_events",
+			data: event
+		});
+		await executor.batch([{
+			sql: `INSERT INTO bundle_installations (${columns.join(", ")})
+          SELECT ${d1Placeholders(columns.length)}
+          WHERE NOT EXISTS (SELECT 1 FROM bundle_events WHERE id = json_extract(?, '$'))
+          ON CONFLICT(install_id) DO UPDATE SET ${columns.filter((column) => column !== "install_id").map((column) => `${column} = excluded.${column}`).join(", ")}
+          WHERE (excluded.received_at_ms, excluded.id) >
+            (bundle_installations.received_at_ms, bundle_installations.id)`,
+			params: encodeD1Values([...Object.values(installation), event.id])
+		}, {
+			...eventInsert,
+			sql: eventInsert.sql.replace(" RETURNING *", " ON CONFLICT(id) DO NOTHING")
+		}]);
+	},
 	async create(input) {
 		const query = insertQuery(input);
 		const rows = await executor.query(query.sql, query.params);
@@ -845,6 +893,7 @@ const createD1Implementation = (executor) => ({
 			case "bundle_patches": return parseD1Row("bundle_patches", rows[0]);
 			case "channels": return parseD1Row("channels", rows[0]);
 			case "bundle_events": return parseD1Row("bundle_events", rows[0]);
+			case "bundle_installations": return parseD1Row("bundle_installations", rows[0]);
 			case "api_keys": return parseD1Row("api_keys", rows[0]);
 			case "releases": return parseD1Row("releases", rows[0]);
 			case "release_catalogs": return parseD1Row("release_catalogs", rows[0]);
@@ -859,6 +908,7 @@ const createD1Implementation = (executor) => ({
 			case "api_keys": return parseD1Row("api_keys", rows[0]);
 			case "releases": return parseD1Row("releases", rows[0]);
 			case "release_catalogs": return parseD1Row("release_catalogs", rows[0]);
+			case "bundle_installations": return parseD1Row("bundle_installations", rows[0]);
 		}
 	},
 	async delete(input) {
@@ -877,6 +927,7 @@ const createD1Implementation = (executor) => ({
 			case "api_keys": return parseD1Row("api_keys", rows[0]);
 			case "releases": return parseD1Row("releases", rows[0]);
 			case "release_catalogs": return parseD1Row("release_catalogs", rows[0]);
+			case "bundle_installations": return parseD1Row("bundle_installations", rows[0]);
 		}
 	},
 	findMany: (input) => findManyD1Rows(executor, input),
@@ -926,7 +977,11 @@ const d1Database = (config) => {
 		};
 		const page = await cloudflare$1.d1.database.query(config.databaseId, { ...body });
 		const results = [];
-		for await (const resultPage of page.iterPages()) for (const result of resultPage.result) results.push(result.results ?? []);
+		for await (const resultPage of page.iterPages()) for (const result of resultPage.result) {
+			if (result.success === false) throw new D1ExecutionError();
+			results.push(result.results ?? []);
+		}
+		if (results.length !== statements.length) throw new D1ExecutionError();
 		return results;
 	};
 	const adapter = (0, _hot_updater_plugin_core_internal.createDatabasePluginAdapter)("d1Database", createD1Implementation({
@@ -1044,7 +1099,8 @@ const parseTemplate = ({ templates, expressions, tokens, index, template }) => {
 	const newTokens = concatTokens(tokens, nextTokens, leadingWhitespaces);
 	if (index === expressions.length) return newTokens;
 	const expression = expressions[index];
-	return concatTokens(newTokens, Array.isArray(expression) ? expression.map((expression) => parseExpression(expression)) : [parseExpression(expression)], trailingWhitespaces);
+	const expressionTokens = Array.isArray(expression) ? expression.map((expression) => parseExpression(expression)) : [parseExpression(expression)];
+	return concatTokens(newTokens, expressionTokens, trailingWhitespaces);
 };
 const splitByWhitespaces = (template, rawTemplate) => {
 	if (rawTemplate.length === 0) return {
@@ -1077,7 +1133,7 @@ const splitByWhitespaces = (template, rawTemplate) => {
 		trailingWhitespaces
 	};
 };
-const DELIMITERS = new Set([
+const DELIMITERS = /* @__PURE__ */ new Set([
 	" ",
 	"	",
 	"\r",
@@ -1129,7 +1185,8 @@ const normalizeFdSpecificOptions = (options) => {
 };
 const normalizeFdSpecificOption = (options, optionName) => {
 	const optionBaseArray = Array.from({ length: getStdioLength(options) + 1 });
-	return addDefaultValue$1(normalizeFdSpecificValue(options[optionName], optionBaseArray, optionName), optionName);
+	const optionArray = normalizeFdSpecificValue(options[optionName], optionBaseArray, optionName);
+	return addDefaultValue$1(optionArray, 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(optionValue) ? normalizeOptionObject(optionValue, optionArray, optionName) : optionArray.fill(optionValue);
@@ -1162,7 +1219,7 @@ const addDefaultValue$1 = (optionArray, optionName) => optionArray.map((optionVa
 const DEFAULT_OPTIONS = {
 	lines: false,
 	buffer: true,
-	maxBuffer: 1e3 * 1e3 * 100,
+	maxBuffer: 1e8,
 	verbose: (0, node_util.debuglog)("execa").enabled ? "full" : "none",
 	stripFinalNewline: true
 };
@@ -1210,7 +1267,7 @@ const escapeControlCharacter = (character) => {
 };
 const getSpecialCharRegExp = () => {
 	try {
-		return /* @__PURE__ */ new RegExp("\\p{Separator}|\\p{Other}", "gu");
+		return new RegExp("\\p{Separator}|\\p{Other}", "gu");
 	} catch {
 		return /[\s\u0000-\u001F\u007F-\u009F\u00AD]/g;
 	}
@@ -1630,11 +1687,13 @@ 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 finalLines = applyVerboseOnLines(getPrintedLines(verboseMessage, getVerboseObject({
+	const verboseObject = getVerboseObject({
 		type,
 		result,
 		verboseInfo
-	})), verboseInfo, fdNumber);
+	});
+	const printedLines = getPrintedLines(verboseMessage, verboseObject);
+	const finalLines = applyVerboseOnLines(printedLines, verboseInfo, fdNumber);
 	if (finalLines !== "") console.warn(finalLines.slice(0, -1));
 };
 const getVerboseObject = ({ type, result, verboseInfo: { escapedCommand, commandId, rawOptions: { piped = false, ...options } } }) => ({
@@ -1657,7 +1716,8 @@ const getPrintedLine = (verboseObject) => {
 	};
 };
 const serializeVerboseMessage = (message) => {
-	return escapeLines(typeof message === "string" ? message : (0, node_util.inspect)(message)).replaceAll("	", " ".repeat(TAB_SIZE));
+	const messageString = typeof message === "string" ? message : (0, node_util.inspect)(message);
+	return escapeLines(messageString).replaceAll("	", " ".repeat(TAB_SIZE));
 };
 const TAB_SIZE = 2;
 //#endregion
@@ -1702,7 +1762,8 @@ const getDurationMs = (startTime) => Number(node_process.hrtime.bigint() - start
 const handleCommand = (filePath, rawArguments, rawOptions) => {
 	const startTime = getStartTime();
 	const { command, escapedCommand } = joinCommand(filePath, rawArguments);
-	const verboseInfo = getVerboseInfo(normalizeFdSpecificOption(rawOptions, "verbose"), escapedCommand, { ...rawOptions });
+	const verbose = normalizeFdSpecificOption(rawOptions, "verbose");
+	const verboseInfo = getVerboseInfo(verbose, escapedCommand, { ...rawOptions });
 	logCommand(escapedCommand, verboseInfo);
 	return {
 		command,
@@ -1823,7 +1884,8 @@ var require_which = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	const getNotFoundError = (cmd) => Object.assign(/* @__PURE__ */ new Error(`not found: ${cmd}`), { code: "ENOENT" });
 	const getPathInfo = (cmd, opt) => {
 		const colon = opt.colon || COLON;
-		const pathEnv = cmd.match(/\//) || isWindows && cmd.match(/\\/) ? [""] : [...isWindows ? [process.cwd()] : [], ...(opt.path || process.env.PATH || "").split(colon)];
+		const pathEnv = cmd.match(/\//) || isWindows && cmd.match(/\\/) ? [""] : [...isWindows ? [process.cwd()] : [], ...(opt.path || process.env.PATH || 
+		/* istanbul ignore next: very unusual */ "").split(colon)];
 		const pathExtExe = isWindows ? opt.pathExt || process.env.PATHEXT || ".EXE;.CMD;.BAT;.COM" : "";
 		const pathExt = isWindows ? pathExtExe.split(colon) : [""];
 		if (isWindows) {
@@ -1848,14 +1910,17 @@ var require_which = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 			const ppRaw = pathEnv[i];
 			const pathPart = /^".*"$/.test(ppRaw) ? ppRaw.slice(1, -1) : ppRaw;
 			const pCmd = path$13.join(pathPart, cmd);
-			resolve(subStep(!pathPart && /^\.[\\\/]/.test(cmd) ? cmd.slice(0, 2) + pCmd : pCmd, i, 0));
+			const p = !pathPart && /^\.[\\\/]/.test(cmd) ? cmd.slice(0, 2) + pCmd : pCmd;
+			resolve(subStep(p, i, 0));
 		});
 		const subStep = (p, i, ii) => new Promise((resolve, reject) => {
 			if (ii === pathExt.length) return resolve(step(i + 1));
 			const ext = pathExt[ii];
 			isexe(p + ext, { pathExt: pathExtExe }, (er, is) => {
-				if (!er && is) if (opt.all) found.push(p + ext);
-				else return resolve(p + ext);
+				if (!er && is) {
+					if (opt.all) found.push(p + ext);
+					else return resolve(p + ext);
+				}
 				return resolve(subStep(p, i, ii + 1));
 			});
 		});
@@ -1873,8 +1938,10 @@ var require_which = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 			for (let j = 0; j < pathExt.length; j++) {
 				const cur = p + pathExt[j];
 				try {
-					if (isexe.sync(cur, { pathExt: pathExtExe })) if (opt.all) found.push(cur);
-					else return cur;
+					if (isexe.sync(cur, { pathExt: pathExtExe })) {
+						if (opt.all) found.push(cur);
+						else return cur;
+					}
 				} catch (ex) {}
 			}
 		}
@@ -2565,7 +2632,7 @@ const normalizeForceKillAfterDelay = (forceKillAfterDelay) => {
 	if (!Number.isFinite(forceKillAfterDelay) || forceKillAfterDelay < 0) throw new TypeError(`Expected the \`forceKillAfterDelay\` option to be a non-negative integer, got \`${forceKillAfterDelay}\` (${typeof forceKillAfterDelay})`);
 	return forceKillAfterDelay;
 };
-const DEFAULT_FORCE_KILL_TIMEOUT = 1e3 * 5;
+const DEFAULT_FORCE_KILL_TIMEOUT = 5e3;
 const subprocessKill = ({ kill, options: { forceKillAfterDelay, killSignal }, onInternalError, context, controller }, signalOrError, errorArgument) => {
 	const { signal, error } = parseKillArguments(signalOrError, errorArgument, killSignal);
 	emitKillError(error, onInternalError);
@@ -2667,7 +2734,7 @@ const handleSerializationError = ({ error, methodName, isSubprocess, message })
 	if (isSerializationError(error)) throw new Error(`${getMethodName(methodName, isSubprocess)}'s argument type is invalid: the message cannot be serialized: ${String(message)}.`, { cause: error });
 };
 const isSerializationError = ({ code, message }) => SERIALIZATION_ERROR_CODES.has(code) || SERIALIZATION_ERROR_MESSAGES.some((serializationErrorMessage) => message.includes(serializationErrorMessage));
-const SERIALIZATION_ERROR_CODES = new Set(["ERR_MISSING_ARGS", "ERR_INVALID_ARG_TYPE"]);
+const SERIALIZATION_ERROR_CODES = /* @__PURE__ */ new Set(["ERR_MISSING_ARGS", "ERR_INVALID_ARG_TYPE"]);
 const SERIALIZATION_ERROR_MESSAGES = [
 	"could not be cloned",
 	"circular structure",
@@ -2877,7 +2944,8 @@ 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 hasListeners = hasMessageListeners(anyProcess, getIpcEmitter(anyProcess, channel, isSubprocess));
+	const ipcEmitter = getIpcEmitter(anyProcess, channel, isSubprocess);
+	const hasListeners = hasMessageListeners(anyProcess, ipcEmitter);
 	return {
 		id: count++,
 		type: REQUEST_TYPE,
@@ -3109,7 +3177,8 @@ const throwOnGracefulCancel = ({ subprocess, cancelSignal, gracefulCancel, force
 })] : [];
 const sendOnAbort = async ({ subprocess, cancelSignal, forceKillAfterDelay, context, controller: { signal } }) => {
 	await onAbortedSignal(cancelSignal, signal);
-	await sendAbort(subprocess, getReason(cancelSignal));
+	const reason = getReason(cancelSignal);
+	await sendAbort(subprocess, reason);
 	killOnTimeout({
 		kill: subprocess.kill,
 		forceKillAfterDelay,
@@ -3221,8 +3290,8 @@ Please rename it to ${serializeEncoding(correctEncoding)}.`);
 	throw new TypeError(`Invalid option \`encoding: ${serializeEncoding(encoding)}\`.
 Please rename it to one of: ${correctEncodings}.`);
 };
-const TEXT_ENCODINGS = new Set(["utf8", "utf16le"]);
-const BINARY_ENCODINGS = new Set([
+const TEXT_ENCODINGS = /* @__PURE__ */ new Set(["utf8", "utf16le"]);
+const BINARY_ENCODINGS = /* @__PURE__ */ new Set([
 	"buffer",
 	"hex",
 	"base64",
@@ -3230,7 +3299,7 @@ const BINARY_ENCODINGS = new Set([
 	"latin1",
 	"ascii"
 ]);
-const ENCODINGS = new Set([...TEXT_ENCODINGS, ...BINARY_ENCODINGS]);
+const ENCODINGS = /* @__PURE__ */ new Set([...TEXT_ENCODINGS, ...BINARY_ENCODINGS]);
 const getCorrectEncoding = (encoding) => {
 	if (encoding === null) return "buffer";
 	if (typeof encoding !== "string") return;
@@ -3277,7 +3346,8 @@ 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 options = addDefaultOptions(normalizeFdSpecificOptions(initialOptions));
+	const fdOptions = normalizeFdSpecificOptions(initialOptions);
+	const options = addDefaultOptions(fdOptions);
 	validateTimeout(options);
 	validateEncoding(options);
 	validateIpcInputOption(options);
@@ -3478,14 +3548,17 @@ const getStreamContents$1 = async (stream, { init, convertChunk, getSize, trunca
 	const state = init();
 	state.length = 0;
 	try {
-		for await (const chunk of asyncIterable) appendChunk({
-			convertedChunk: convertChunk[getChunkType(chunk)](chunk, state),
-			state,
-			getSize,
-			truncateChunk,
-			addChunk,
-			maxBuffer
-		});
+		for await (const chunk of asyncIterable) {
+			const convertedChunk = convertChunk[getChunkType(chunk)](chunk, state);
+			appendChunk({
+				convertedChunk,
+				state,
+				getSize,
+				truncateChunk,
+				addChunk,
+				maxBuffer
+			});
+		}
 		appendFinalChunk({
 			state,
 			convertChunk,
@@ -3771,7 +3844,8 @@ 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 escapedOriginalMessage = escapeLines(fixCwdError(isExecaError(originalError) ? originalError.originalMessage : String(originalError?.message ?? originalError), cwd));
+	const originalMessage = isExecaError(originalError) ? originalError.originalMessage : String(originalError?.message ?? originalError);
+	const escapedOriginalMessage = escapeLines(fixCwdError(originalMessage, cwd));
 	return escapedOriginalMessage === "" ? void 0 : escapedOriginalMessage;
 };
 const serializeIpcMessage = (ipcMessage) => typeof ipcMessage === "string" ? ipcMessage : (0, node_util.inspect)(ipcMessage);
@@ -3982,26 +4056,28 @@ function prettyMilliseconds(milliseconds, options) {
 		add(Number(parsed.hours), "hour", "h");
 	}
 	add(Number(parsed.minutes), "minute", "m");
-	if (!options.hideSeconds) if (options.separateMilliseconds || options.formatSubMilliseconds || !options.colonNotation && milliseconds < 1e3 && !options.subSecondsAsDecimals) {
-		const seconds = Number(parsed.seconds);
-		const milliseconds = Number(parsed.milliseconds);
-		const microseconds = Number(parsed.microseconds);
-		const nanoseconds = Number(parsed.nanoseconds);
-		add(seconds, "second", "s");
-		if (options.formatSubMilliseconds) {
-			add(milliseconds, "millisecond", "ms");
-			add(microseconds, "microsecond", "µs");
-			add(nanoseconds, "nanosecond", "ns");
+	if (!options.hideSeconds) {
+		if (options.separateMilliseconds || options.formatSubMilliseconds || !options.colonNotation && milliseconds < 1e3 && !options.subSecondsAsDecimals) {
+			const seconds = Number(parsed.seconds);
+			const milliseconds = Number(parsed.milliseconds);
+			const microseconds = Number(parsed.microseconds);
+			const nanoseconds = Number(parsed.nanoseconds);
+			add(seconds, "second", "s");
+			if (options.formatSubMilliseconds) {
+				add(milliseconds, "millisecond", "ms");
+				add(microseconds, "microsecond", "µs");
+				add(nanoseconds, "nanosecond", "ns");
+			} else {
+				const millisecondsAndBelow = milliseconds + microseconds / 1e3 + nanoseconds / 1e6;
+				const millisecondsDecimalDigits = typeof options.millisecondsDecimalDigits === "number" ? options.millisecondsDecimalDigits : 0;
+				const millisecondsString = millisecondsDecimalDigits ? millisecondsAndBelow.toFixed(millisecondsDecimalDigits) : millisecondsAndBelow >= 1 ? Math.round(millisecondsAndBelow) : Math.ceil(millisecondsAndBelow);
+				add(Number.parseFloat(millisecondsString), "millisecond", "ms", millisecondsString);
+			}
 		} else {
-			const millisecondsAndBelow = milliseconds + microseconds / 1e3 + nanoseconds / 1e6;
-			const millisecondsDecimalDigits = typeof options.millisecondsDecimalDigits === "number" ? options.millisecondsDecimalDigits : 0;
-			const millisecondsString = millisecondsDecimalDigits ? millisecondsAndBelow.toFixed(millisecondsDecimalDigits) : millisecondsAndBelow >= 1 ? Math.round(millisecondsAndBelow) : Math.ceil(millisecondsAndBelow);
-			add(Number.parseFloat(millisecondsString), "millisecond", "ms", millisecondsString);
+			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);
 		}
-	} else {
-		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);
 	}
 	if (result.length === 0) return sign + "0" + (options.verbose ? " milliseconds" : "ms");
 	const separator = options.colonNotation ? ":" : " ";
@@ -4026,9 +4102,10 @@ const logResult = (result, verboseInfo) => {
 	logDuration(result, verboseInfo);
 };
 const logDuration = (result, verboseInfo) => {
+	const verboseMessage = `(done in ${prettyMilliseconds(result.durationMs)})`;
 	verboseLog({
 		type: "duration",
-		verboseMessage: `(done in ${prettyMilliseconds(result.durationMs)})`,
+		verboseMessage,
 		verboseInfo,
 		result
 	});
@@ -4096,10 +4173,10 @@ const isTransformOptions = (value) => isPlainObject(value) && (value.transform !
 const isUrl = (value) => Object.prototype.toString.call(value) === "[object URL]";
 const isRegularUrl = (value) => isUrl(value) && value.protocol !== "file:";
 const isFilePathObject = (value) => isPlainObject(value) && Object.keys(value).length > 0 && Object.keys(value).every((key) => FILE_PATH_KEYS.has(key)) && isFilePathString(value.file);
-const FILE_PATH_KEYS = new Set(["file", "append"]);
+const FILE_PATH_KEYS = /* @__PURE__ */ new Set(["file", "append"]);
 const isFilePathString = (file) => typeof file === "string";
 const isUnknownStdioString = (type, value) => type === "native" && typeof value === "string" && !KNOWN_STDIO_STRINGS.has(value);
-const KNOWN_STDIO_STRINGS = new Set([
+const KNOWN_STDIO_STRINGS = /* @__PURE__ */ new Set([
 	"ipc",
 	"ignore",
 	"inherit",
@@ -4113,24 +4190,24 @@ const isTransformStream = (value) => isReadableStream(value?.readable) && isWrit
 const isAsyncIterableObject = (value) => isObject(value) && typeof value[Symbol.asyncIterator] === "function";
 const isIterableObject = (value) => isObject(value) && typeof value[Symbol.iterator] === "function";
 const isObject = (value) => typeof value === "object" && value !== null;
-const TRANSFORM_TYPES = new Set([
+const TRANSFORM_TYPES = /* @__PURE__ */ new Set([
 	"generator",
 	"asyncGenerator",
 	"duplex",
 	"webTransform"
 ]);
-const FILE_TYPES = new Set([
+const FILE_TYPES = /* @__PURE__ */ new Set([
 	"fileUrl",
 	"filePath",
 	"fileNumber"
 ]);
-const SPECIAL_DUPLICATE_TYPES_SYNC = new Set(["fileUrl", "filePath"]);
-const SPECIAL_DUPLICATE_TYPES = new Set([
+const SPECIAL_DUPLICATE_TYPES_SYNC = /* @__PURE__ */ new Set(["fileUrl", "filePath"]);
+const SPECIAL_DUPLICATE_TYPES = /* @__PURE__ */ new Set([
 	...SPECIAL_DUPLICATE_TYPES_SYNC,
 	"webStream",
 	"nodeStream"
 ]);
-const FORBID_DUPLICATE_TYPES = new Set(["webTransform", "duplex"]);
+const FORBID_DUPLICATE_TYPES = /* @__PURE__ */ new Set(["webTransform", "duplex"]);
 const TYPE_TO_MESSAGE = {
 	generator: "a generator",
 	asyncGenerator: "an async generator",
@@ -4463,7 +4540,8 @@ 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;
-	throwOnDuplicateStream(duplicateStdioItems.find((stdioItem) => stdioItem.direction !== direction), optionName, type);
+	const differentStdioItem = duplicateStdioItems.find((stdioItem) => stdioItem.direction !== direction);
+	throwOnDuplicateStream(differentStdioItem, optionName, type);
 	return direction === "output" ? duplicateStdioItems[0].stream : void 0;
 };
 const hasSameValue = ({ type, value }, secondValue) => {
@@ -4472,7 +4550,8 @@ const hasSameValue = ({ type, value }, secondValue) => {
 	return value === secondValue;
 };
 const validateDuplicateTransform = ({ otherStdioItems, type, value, optionName }) => {
-	throwOnDuplicateStream(otherStdioItems.find(({ value: { transform } }) => transform === value.transform), optionName, type);
+	const duplicateStdioItem = otherStdioItems.find(({ value: { transform } }) => transform === value.transform);
+	throwOnDuplicateStream(duplicateStdioItem, 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.`);
@@ -4480,13 +4559,14 @@ const throwOnDuplicateStream = (stdioItem, optionName, type) => {
 //#endregion
 //#region ../../node_modules/.pnpm/execa@9.5.2/node_modules/execa/lib/stdio/handle.js
 const handleStdio = (addProperties, options, verboseInfo, isSync) => {
+	const initialFileDescriptors = normalizeStdioOption(options, verboseInfo, isSync).map((stdioOption, fdNumber) => getFileDescriptor({
+		stdioOption,
+		fdNumber,
+		options,
+		isSync
+	}));
 	const fileDescriptors = getFinalFileDescriptors({
-		initialFileDescriptors: normalizeStdioOption(options, verboseInfo, isSync).map((stdioOption, fdNumber) => getFileDescriptor({
-			stdioOption,
-			fdNumber,
-			options,
-			isSync
-		})),
+		initialFileDescriptors,
 		addProperties,
 		options,
 		isSync
@@ -4503,13 +4583,14 @@ const getFileDescriptor = ({ stdioOption, fdNumber, options, isSync }) => {
 		optionName
 	});
 	const direction = getStreamDirection(initialStdioItems, fdNumber, optionName);
-	const normalizedStdioItems = normalizeTransforms(initialStdioItems.map((stdioItem) => handleNativeStream({
+	const stdioItems = initialStdioItems.map((stdioItem) => handleNativeStream({
 		stdioItem,
 		isStdioArray,
 		fdNumber,
 		direction,
 		isSync
-	})), optionName, direction, options);
+	}));
+	const normalizedStdioItems = normalizeTransforms(stdioItems, optionName, direction, options);
 	const objectMode = getFdObjectMode(normalizedStdioItems, direction);
 	validateFileObjectMode(normalizedStdioItems, objectMode);
 	return {
@@ -4519,7 +4600,8 @@ const getFileDescriptor = ({ stdioOption, fdNumber, options, isSync }) => {
 	};
 };
 const initializeStdioItems = ({ stdioOption, fdNumber, options, optionName }) => {
-	const stdioItems = filterDuplicates([...(Array.isArray(stdioOption) ? stdioOption : [stdioOption]).map((value) => initializeStdioItem(value, optionName)), ...handleInputOptions(options, fdNumber)]);
+	const initialStdioItems = [...(Array.isArray(stdioOption) ? stdioOption : [stdioOption]).map((value) => initializeStdioItem(value, optionName)), ...handleInputOptions(options, fdNumber)];
+	const stdioItems = filterDuplicates(initialStdioItems);
 	const isStdioArray = stdioItems.length > 1;
 	validateStdioArray(stdioItems, isStdioArray, optionName);
 	validateStreams(stdioItems);
@@ -4538,7 +4620,7 @@ const validateStdioArray = (stdioItems, isStdioArray, optionName) => {
 	if (!isStdioArray) return;
 	for (const { value, optionName } of stdioItems) if (INVALID_STDIO_ARRAY_OPTIONS.has(value)) throw new Error(`The \`${optionName}\` option must not include \`${value}\`.`);
 };
-const INVALID_STDIO_ARRAY_OPTIONS = new Set(["ignore", "ipc"]);
+const INVALID_STDIO_ARRAY_OPTIONS = /* @__PURE__ */ new Set(["ignore", "ipc"]);
 const validateStreams = (stdioItems) => {
 	for (const stdioItem of stdioItems) validateFileStdio(stdioItem);
 };
@@ -4867,7 +4949,10 @@ const generatorToStream = ({ value, value: { transform, final, writableObjectMod
 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) chunks = runTransformSync(addInternalGenerators(value, encoding, optionName), chunks);
+	for (const { value, optionName } of reversedGenerators) {
+		const generators = addInternalGenerators(value, encoding, optionName);
+		chunks = runTransformSync(generators, chunks);
+	}
 	return chunks;
 };
 const addInternalGenerators = ({ transform, final, binary, writableObjectMode, readableObjectMode, preserveNewlines }, encoding, optionName) => {
@@ -4903,7 +4988,8 @@ 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.`);
 	}
-	options.input = joinToUint8Array(allStdioItems.map(({ contents }) => contents).map((contents) => applySingleInputGeneratorsSync(contents, stdioItems)));
+	const transformedContents = allStdioItems.map(({ contents }) => contents).map((contents) => applySingleInputGeneratorsSync(contents, stdioItems));
+	options.input = joinToUint8Array(transformedContents);
 };
 const applySingleInputGeneratorsSync = (contents, stdioItems) => {
 	const newContents = runGeneratorsSync(contents, stdioItems, "utf8", true);
@@ -4918,7 +5004,7 @@ const validateSerializable = (newContents) => {
 //#region ../../node_modules/.pnpm/execa@9.5.2/node_modules/execa/lib/verbose/output.js
 const shouldLogOutput = ({ stdioItems, encoding, verboseInfo, fdNumber }) => fdNumber !== "all" && isFullVerbose(verboseInfo, fdNumber) && !BINARY_ENCODINGS.has(encoding) && fdUsesVerbose(fdNumber) && (stdioItems.some(({ type, value }) => type === "native" && PIPED_STDIO_VALUES.has(value)) || stdioItems.every(({ type }) => TRANSFORM_TYPES.has(type)));
 const fdUsesVerbose = (fdNumber) => fdNumber === 1 || fdNumber === 2;
-const PIPED_STDIO_VALUES = new Set(["pipe", "overlapped"]);
+const PIPED_STDIO_VALUES = /* @__PURE__ */ new Set(["pipe", "overlapped"]);
 const logLines = async (linesIterable, stream, fdNumber, verboseInfo) => {
 	for await (const line of linesIterable) if (!isPipingStream(stream)) logLine(line, fdNumber, verboseInfo);
 };
@@ -4927,9 +5013,10 @@ 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: serializeVerboseMessage(line),
+		verboseMessage,
 		fdNumber,
 		verboseInfo
 	});
@@ -4955,10 +5042,12 @@ const transformOutputSync = ({ fileDescriptors, syncResult: { output }, options,
 };
 const transformOutputResultSync = ({ result, fileDescriptors, fdNumber, state, outputFiles, isMaxBuffer, verboseInfo }, { buffer, encoding, lines, stripFinalNewline, maxBuffer }) => {
 	if (result === null) return;
-	const uint8ArrayResult = bufferToUint8Array(truncateMaxBufferSync(result, isMaxBuffer, maxBuffer));
+	const truncatedResult = truncateMaxBufferSync(result, isMaxBuffer, maxBuffer);
+	const uint8ArrayResult = bufferToUint8Array(truncatedResult);
 	const { stdioItems, objectMode } = fileDescriptors[fdNumber];
+	const chunks = runOutputGeneratorsSync([uint8ArrayResult], stdioItems, encoding, state);
 	const { serializedResult, finalResult = serializedResult } = serializeChunks({
-		chunks: runOutputGeneratorsSync([uint8ArrayResult], stdioItems, encoding, state),
+		chunks,
 		objectMode,
 		encoding,
 		lines,
@@ -5082,7 +5171,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);
-	return handleResult(spawnSubprocessSync({
+	const result = spawnSubprocessSync({
 		file,
 		commandArguments,
 		options,
@@ -5091,11 +5180,13 @@ const execaCoreSync = (rawFile, rawArguments, rawOptions) => {
 		verboseInfo,
 		fileDescriptors,
 		startTime
-	}), verboseInfo, options);
+	});
+	return handleResult(result, verboseInfo, options);
 };
 const handleSyncArguments = (rawFile, rawArguments, rawOptions) => {
 	const { command, escapedCommand, startTime, verboseInfo } = handleCommand(rawFile, rawArguments, rawOptions);
-	const { file, commandArguments, options } = normalizeOptions(rawFile, rawArguments, normalizeSyncOptions(rawOptions));
+	const syncOptions = normalizeSyncOptions(rawOptions);
+	const { file, commandArguments, options } = normalizeOptions(rawFile, rawArguments, syncOptions);
 	validateSyncOptions(options);
 	return {
 		file,
@@ -5140,14 +5231,16 @@ 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: output.map((stdioOutput, fdNumber) => stripNewline(stdioOutput, options, fdNumber)),
-		all: stripNewline(getAllSync(output, options), options, "all"),
+		stdio,
+		all,
 		options,
 		command,
 		escapedCommand,
@@ -5157,7 +5250,8 @@ const spawnSubprocessSync = ({ file, commandArguments, options, command, escaped
 const runSubprocessSync = ({ file, commandArguments, options, command, escapedCommand, fileDescriptors, startTime }) => {
 	try {
 		addInputOptionsSync(fileDescriptors, options);
-		return (0, node_child_process.spawnSync)(file, commandArguments, normalizeSpawnSyncOptions(options));
+		const normalizedOptions = normalizeSpawnSyncOptions(options);
+		return (0, node_child_process.spawnSync)(file, commandArguments, normalizedOptions);
 	} catch (error) {
 		return makeEarlyError({
 			error,
@@ -5371,17 +5465,18 @@ const handleEarlyError = ({ error, command, escapedCommand, fileDescriptors, opt
 		writable,
 		duplex
 	});
+	const earlyError = makeEarlyError({
+		error,
+		command,
+		escapedCommand,
+		fileDescriptors,
+		options,
+		startTime,
+		isSync: false
+	});
 	return {
 		subprocess,
-		promise: handleDummyPromise(makeEarlyError({
-			error,
-			command,
-			escapedCommand,
-			fileDescriptors,
-			options,
-			startTime,
-			isSync: false
-		}), verboseInfo, options)
+		promise: handleDummyPromise(earlyError, verboseInfo, options)
 	};
 };
 const createDummyStreams = (subprocess, fileDescriptors) => {
@@ -5565,8 +5660,10 @@ const endWhenStreamsDone = async ({ passThroughStream, stream, streams, ended, a
 		controller.abort();
 		updateMaxListeners(passThroughStream, -PASSTHROUGH_LISTENERS_PER_STREAM);
 	}
-	if (streams.size > 0 && streams.size === ended.size + aborted.size) if (ended.size === 0 && aborted.size > 0) abortStream(passThroughStream);
-	else endStream(passThroughStream);
+	if (streams.size > 0 && streams.size === ended.size + aborted.size) {
+		if (ended.size === 0 && aborted.size > 0) abortStream(passThroughStream);
+		else endStream(passThroughStream);
+	}
 };
 const afterMergedStreamFinished = async (onFinished, stream, { signal }) => {
 	try {
@@ -5672,7 +5769,10 @@ const pipeOutputAsync = (subprocess, fileDescriptors, controller) => {
 			controller
 		});
 	}
-	for (const [outputStream, inputStreams] of pipeGroups.entries()) pipeStreams(inputStreams.length === 1 ? inputStreams[0] : mergeStreams(inputStreams), outputStream);
+	for (const [outputStream, inputStreams] of pipeGroups.entries()) {
+		const inputStream = inputStreams.length === 1 ? inputStreams[0] : mergeStreams(inputStreams);
+		pipeStreams(inputStream, outputStream);
+	}
 };
 const pipeTransform = (subprocess, stream, direction, fdNumber) => {
 	if (direction === "output") pipeStreams(subprocess.stdio[fdNumber], stream);
@@ -6161,12 +6261,13 @@ 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: (0, node_events.on)(stream, "data", {
-			signal: controller.signal,
-			highWaterMark: HIGH_WATER_MARK,
-			highWatermark: HIGH_WATER_MARK
-		}),
+		onStdoutChunk,
 		controller,
 		binary,
 		shouldEncode,
@@ -6210,12 +6311,13 @@ const getStreamOutput = async ({ stream, onStreamEnd, fdNumber, encoding, buffer
 		await Promise.all([resumeStream(stream), logPromise]);
 		return;
 	}
+	const stripFinalNewlineValue = getStripFinalNewline(stripFinalNewline, fdNumber);
 	const iterable = iterateForResult({
 		stream,
 		onStreamEnd,
 		lines,
 		encoding,
-		stripFinalNewline: getStripFinalNewline(stripFinalNewline, fdNumber),
+		stripFinalNewline: stripFinalNewlineValue,
 		allMixed
 	});
 	const [output] = await Promise.all([getStreamContents({
@@ -6235,14 +6337,15 @@ const logOutputAsync = async ({ stream, onStreamEnd, fdNumber, encoding, allMixe
 		verboseInfo,
 		fdNumber
 	})) return;
-	await logLines(iterateForResult({
+	const linesIterable = iterateForResult({
 		stream,
 		onStreamEnd,
 		lines: true,
 		encoding,
 		stripFinalNewline: true,
 		allMixed
-	}), stream, fdNumber, verboseInfo);
+	});
+	await logLines(linesIterable, stream, fdNumber, verboseInfo);
 };
 const resumeStream = async (stream) => {
 	await (0, node_timers_promises.setImmediate)();
@@ -6388,9 +6491,10 @@ 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: serializeVerboseMessage(message),
+		verboseMessage,
 		fdNumber: "ipc",
 		verboseInfo
 	});
@@ -6786,14 +6890,15 @@ 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);
-	return iterateOnStdoutData(iterateOnSubprocessStream({
+	const onStdoutData = iterateOnSubprocessStream({
 		subprocessStdout,
 		subprocess,
 		binary,
 		shouldEncode: true,
 		encoding,
 		preserveNewlines
-	}), subprocessStdout, subprocess);
+	});
+	return iterateOnStdoutData(onStdoutData, subprocessStdout, subprocess);
 };
 const iterateOnStdoutData = async function* (onStdoutData, subprocessStdout, subprocess) {
 	try {
@@ -6953,19 +7058,22 @@ const handlePromise = async ({ subprocess, options, startTime, verboseInfo, file
 	});
 	controller.abort();
 	onInternalError.resolve();
-	return handleResult(getAsyncResult({
+	const stdio = stdioResults.map((stdioResult, fdNumber) => stripNewline(stdioResult, options, fdNumber));
+	const all = stripNewline(allResult, options, "all");
+	const result = getAsyncResult({
 		errorInfo,
 		exitCode,
 		signal,
-		stdio: stdioResults.map((stdioResult, fdNumber) => stripNewline(stdioResult, options, fdNumber)),
-		all: stripNewline(allResult, options, "all"),
+		stdio,
+		all,
 		ipcOutput,
 		context,
 		options,
 		command,
 		escapedCommand,
 		startTime
-	}), verboseInfo, options);
+	});
+	return handleResult(result, verboseInfo, options);
 };
 const getAsyncResult = ({ errorInfo, exitCode, signal, stdio, all, ipcOutput, context, options, command, escapedCommand, startTime }) => "error" in errorInfo ? makeError({
 	error: errorInfo.error,
@@ -7009,7 +7117,7 @@ const mergeOption = (optionName, boundOptionValue, optionValue) => {
 	};
 	return optionValue;
 };
-const DEEP_OPTIONS = new Set(["env", ...FD_SPECIFIC_OPTIONS]);
+const DEEP_OPTIONS = /* @__PURE__ */ new Set(["env", ...FD_SPECIFIC_OPTIONS]);
 //#endregion
 //#region ../../node_modules/.pnpm/execa@9.5.2/node_modules/execa/lib/methods/create.js
 const createExeca = (mapArguments, boundOptions, deepOptions, setBoundExeca) => {
@@ -7036,7 +7144,8 @@ 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 [initialFile, initialArguments, initialOptions] = normalizeParameters(...isTemplateString(firstArgument) ? parseTemplates(firstArgument, nextArguments) : [firstArgument, ...nextArguments]);
+	const callArguments = isTemplateString(firstArgument) ? parseTemplates(firstArgument, nextArguments) : [firstArgument, ...nextArguments];
+	const [initialFile, initialArguments, initialOptions] = normalizeParameters(...callArguments);
 	const mergedOptions = mergeOptions(mergeOptions(deepOptions, boundOptions), initialOptions);
 	const { file = initialFile, commandArguments = initialArguments, options = mergedOptions, isSync = false } = mapArguments({
 		file: initialFile,
@@ -7150,6 +7259,8 @@ const isCloudflareAuthenticationError = (error) => {
 	].some((pattern) => pattern.test(getErrorOutput(error)));
 };
 var CloudflareAuthenticationError = class extends _hot_updater_cli_tools.InitError {
+	source;
+	accountId;
 	name = "CloudflareAuthenticationError";
 	constructor(source, accountId, options) {
 		super([
@@ -7164,6 +7275,7 @@ var CloudflareAuthenticationError = class extends _hot_updater_cli_tools.InitErr
 	}
 };
 var CloudflarePermissionError = class extends _hot_updater_cli_tools.InitError {
+	source;
 	name = "CloudflarePermissionError";
 	constructor(source, { accountId, check, requiredPermission }, options) {
 		super([
@@ -9302,12 +9414,14 @@ var require_parser = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 						s2 = peg$FAILED;
 						if (peg$silentFails === 0) peg$fail(peg$c39);
 					}
-					if (s2 === peg$FAILED) if (input.charCodeAt(peg$currPos) === 69) {
-						s2 = peg$c40;
-						peg$currPos++;
-					} else {
-						s2 = peg$FAILED;
-						if (peg$silentFails === 0) peg$fail(peg$c41);
+					if (s2 === peg$FAILED) {
+						if (input.charCodeAt(peg$currPos) === 69) {
+							s2 = peg$c40;
+							peg$currPos++;
+						} else {
+							s2 = peg$FAILED;
+							if (peg$silentFails === 0) peg$fail(peg$c41);
+						}
 					}
 					if (s2 !== peg$FAILED) {
 						s3 = peg$parseinteger_text();
@@ -10476,12 +10590,14 @@ var require_parser = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 														s11 = peg$FAILED;
 														if (peg$silentFails === 0) peg$fail(peg$c48);
 													}
-													if (s11 === peg$FAILED) if (input.charCodeAt(peg$currPos) === 43) {
-														s11 = peg$c44;
-														peg$currPos++;
-													} else {
-														s11 = peg$FAILED;
-														if (peg$silentFails === 0) peg$fail(peg$c45);
+													if (s11 === peg$FAILED) {
+														if (input.charCodeAt(peg$currPos) === 43) {
+															s11 = peg$c44;
+															peg$currPos++;
+														} else {
+															s11 = peg$FAILED;
+															if (peg$silentFails === 0) peg$fail(peg$c45);
+														}
 													}
 													if (s11 !== peg$FAILED) {
 														s12 = peg$parseDIGIT_OR_UNDER();
@@ -11238,9 +11354,7 @@ var require_compiler = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 					case "ObjectPath":
 						setPath(node);
 						break;
-					case "ArrayPath":
-						addTableArray(node);
-						break;
+					case "ArrayPath": addTableArray(node);
 				}
 			}
 			return data;
@@ -11320,9 +11434,10 @@ var require_compiler = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 				var key = keys[i];
 				traversed.push(key);
 				traversedPath = traversed.join(".");
-				if (typeof ctx[key] === "undefined") if (i === keys.length - 1) ctx[key] = value;
-				else ctx[key] = Object.create(null);
-				else if (i !== keys.length - 1 && valueAssignments.indexOf(traversedPath) > -1) genError("Cannot redefine existing key '" + traversedPath + "'.", line, column);
+				if (typeof ctx[key] === "undefined") {
+					if (i === keys.length - 1) ctx[key] = value;
+					else ctx[key] = Object.create(null);
+				} else if (i !== keys.length - 1 && valueAssignments.indexOf(traversedPath) > -1) genError("Cannot redefine existing key '" + traversedPath + "'.", line, column);
 				ctx = ctx[key];
 				if (ctx instanceof Array && ctx.length && i < keys.length - 1) ctx = ctx[ctx.length - 1];
 			}
@@ -12162,7 +12277,8 @@ export default App;`;
 const deployWorker = async (apiToken, accountId, { credentialSource, d1DatabaseId, d1DatabaseName, nonInteractive, r2BucketName, workerName }) => {
 	const cwd = (0, _hot_updater_cli_tools.getCwd)();
 	const cloudflarePackagePath = require.resolve("@hot-updater/cloudflare/package.json", { paths: [cwd] });
-	const { tmpDir, removeTmpDir } = await (0, _hot_updater_cli_tools.copyDirToTmp)(path.default.dirname(cloudflarePackagePath));
+	const cloudflarePackageRoot = path.default.dirname(cloudflarePackagePath);
+	const { tmpDir, removeTmpDir } = await (0, _hot_updater_cli_tools.copyDirToTmp)(cloudflarePackageRoot);
 	const workerRoot = path.default.join(tmpDir, "worker");
 	try {
 		const wranglerConfig = JSON.parse(await fs_promises.default.readFile(path.default.join(workerRoot, "wrangler.json"), "utf-8"));
@@ -12432,13 +12548,16 @@ const runInit = async ({ build, envFile }) => {
 		for await (const resultPage of page.iterPages()) for (const result of resultPage.result) rows.push(...result.results ?? []);
 		return rows;
 	};
-	if (!createD1Database) assertCloudflareInfrastructureCanInitialize((await queryD1(`
+	if (!createD1Database) {
+		const tables = await queryD1(`
       SELECT name
       FROM sqlite_schema
       WHERE type = 'table'
         AND name IN ('bundles', 'release_catalogs')
       ORDER BY name
-    `)).flatMap(({ name }) => typeof name === "string" ? [name] : []), d1DatabaseName);
+    `);
+		assertCloudflareInfrastructureCanInitialize(tables.flatMap(({ name }) => typeof name === "string" ? [name] : []), d1DatabaseName);
+	}
 	const workerScripts = await runCloudflareApiRequest({
 		request: () => cf.workers.scripts.list({ account_id: accountId }),
 		source: infrastructureCredentialSource
@@ -12465,13 +12584,14 @@ const runInit = async ({ build, envFile }) => {
 		secretAccessKey,
 		workerName
 	};
+	const persistCredentialInputs = await (0, _hot_updater_cli_tools.confirmInitInputPersistence)({
+		existingEnv: managedEnv,
+		inputs: resolvedInputs,
+		nonInteractive,
+		provider: initProvider
+	});
 	await (0, _hot_updater_cli_tools.makeEnv)({ ...(0, _hot_updater_cli_tools.getInitProviderEnvVars)({
-		includeConsentInputs: await (0, _hot_updater_cli_tools.confirmInitInputPersistence)({
-			existingEnv: managedEnv,
-			inputs: resolvedInputs,
-			nonInteractive,
-			provider: initProvider
-		}),
+		includeConsentInputs: persistCredentialInputs,
 		inputs: resolvedInputs,
 		provider: initProvider
 	}) });