sv 0.17.0 → 1.0.0-next.0

package/dist/{engine-B7chsCPG.mjs → engine-DlJ4-99M.mjs}

@@ -1,6 +1,8 @@
 import { createRequire } from "node:module";
-import { AGENTS, COMMANDS, KIT3_TSCONFIG, KIT3_TSCONFIG_DEFAULT, Walker, coerceVersion, color, constructCommand, createPrinter, dedent, defineEnv, detect, downloadJson, fileExists, isKit3, isVersionUnsupportedBelow, js, libSubpathImports, loadFile, loadPackageJson, minVersion, parse, pnpm, resolveCommand, resolveCommandArray, resolveLibPrefix, sanitizeName, saveFile, svelte, svelteConfig, transforms } from "@sveltejs/sv-utils";
+import { AGENTS, COMMANDS, Walker, coerceVersion, color, constructCommand, createPrinter, dedent, defineEnv, detect, downloadJson, fileExists, isKit3, isVersionUnsupportedBelow, js, loadFile, loadPackageJson, minVersion, minimizeDiff, parse, pnpm, resolveCommand, resolveCommandArray, resolveLibPrefix, sanitizeName, saveFile, svelte, svelteConfig, transforms } from "@sveltejs/sv-utils";
+import * as fs$1 from "node:fs";
 import fs, { closeSync, existsSync, openSync, readSync, statSync } from "node:fs";
+import * as path$1 from "node:path";
 import path, { basename, delimiter, dirname, isAbsolute, join, normalize, resolve } from "node:path";
 import { promisify, stripVTControlCharacters, styleText } from "node:util";
 import V, { cwd, stdin, stdout } from "node:process";
@@ -10,10 +12,11 @@ import { ReadStream } from "node:tty";
 import { fileURLToPath } from "node:url";
 import childProcess, { exec, spawn, spawnSync } from "node:child_process";
 import { pipeline } from "node:stream/promises";
-import { PassThrough } from "node:stream";
+import { PassThrough, Writable } from "node:stream";
 import { EventEmitter } from "node:events";
 import crypto from "node:crypto";
-import { platform } from "node:os";
+import * as fsp from "node:fs/promises";
+import { cpus, platform } from "node:os";
 import { createGunzip } from "node:zlib";
 //#region \0rolldown/runtime.js
 var __create = Object.create;
@@ -39,18 +42,6 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 }) : target, mod));
 var __require = /* #__PURE__ */ (() => createRequire(import.meta.url))();
 //#endregion
-//#region src/core/deprecated.ts
-const warned = /* @__PURE__ */ new Set();
-/** Emit a one-time deprecation warning. */
-function svDeprecated(message) {
-	if (warned.has(message)) return;
-	warned.add(message);
-	console.warn();
-	console.warn(`   ${color.dim("[sv] Deprecated:")} ${message}`);
-	console.warn(`       Still works. ${color.warning("Warn add-on's author about it.")}`);
-	console.warn();
-}
-//#endregion
 //#region ../../node_modules/.pnpm/fast-string-truncated-width@3.0.3/node_modules/fast-string-truncated-width/dist/utils.js
 const getCodePointsLength = (() => {
 	const SURROGATE_PAIR_RE = /[\uD800-\uDBFF][\uDC00-\uDFFF]/g;
@@ -1348,7 +1339,7 @@ ${i ? styleText("cyan", x$1) : ""}
 //#endregion
 //#region package.json
 var name = "sv";
-var version = "0.17.0";
+var version = "1.0.0-next.0";
 //#endregion
 //#region src/core/errors.ts
 var UnsupportedError = class extends Error {
@@ -1565,6 +1556,27 @@ const filePaths = {
 	viteConfig: "vite.config.js",
 	viteConfigTS: "vite.config.ts"
 };
+async function runAndValidateVerifications(verifications) {
+	const fails = [];
+	for (const verification of verifications) {
+		const { message, success } = await verification.run();
+		if (!success) fails.push({
+			name: verification.name,
+			message
+		});
+	}
+	if (fails.length > 0) {
+		Ce(`- ${fails.map(({ name, message }) => color.warning(`${name} (${message})`)).join("\n- ")}`, "Verifications not met", { format: (line) => line });
+		const force = await le({
+			message: "Verifications failed. Do you wish to continue?",
+			initialValue: false
+		});
+		if (R$2(force) || !force) {
+			ge("Operation cancelled.");
+			V.exit(1);
+		}
+	}
+}
 //#endregion
 //#region src/create/utils.ts
 function mkdirp(dir) {
@@ -5382,6 +5394,26 @@ function boolean(message$1) {
 	};
 }
 /* @__NO_SIDE_EFFECTS__ */
+function literal(literal_, message$1) {
+	return {
+		kind: "schema",
+		type: "literal",
+		reference: literal,
+		expects: /* @__PURE__ */ _stringify(literal_),
+		async: false,
+		literal: literal_,
+		message: message$1,
+		get "~standard"() {
+			return /* @__PURE__ */ _getStandardProps(this);
+		},
+		"~run"(dataset, config$1) {
+			if (dataset.value === this.literal) dataset.typed = true;
+			else _addIssue(this, "type", dataset, config$1);
+			return dataset;
+		}
+	};
+}
+/* @__NO_SIDE_EFFECTS__ */
 function optional(wrapped, default_) {
 	return {
 		kind: "schema",
@@ -5938,7 +5970,7 @@ var ai_tools_default = defineAddon({
 			const { mcpOptions, agentPath, agentLink, configPath, skillsPath, agentsPath, agentExtension, schema, customData, extraFiles } = client;
 			if (!filesAdded.includes(agentPath)) sv.file(agentPath, (content) => {
 				if (content) {
-					filesExistingAlready.push(agentPath);
+					if (!filesExistingAlready.includes(agentPath)) filesExistingAlready.push(agentPath);
 					return false;
 				}
 				filesAdded.push(agentPath);
@@ -6154,8 +6186,8 @@ var better_auth_default = defineAddon({
 		const hasDemo = demoPassword || demoGithub;
 		let drizzleDialect;
 		let d1 = false;
-		sv.devDependency("auth", "^1.6.23");
-		sv.devDependency("better-auth", "^1.6.23");
+		sv.devDependency("auth", "^1.6.24");
+		sv.devDependency("better-auth", "^1.6.24");
 		sv.file(`drizzle.config.${language}`, transforms.script(({ ast }) => {
 			const isProp = (name, node) => node.key.type === "Identifier" && node.key.name === name;
 			Walker.walk(ast, null, { Property(node) {
@@ -6628,9 +6660,14 @@ var drizzle_default = defineAddon({
 		group: "client",
 		default: "libsql",
 		options: [
+			{
+				value: "node-sqlite",
+				label: "node:sqlite",
+				hint: "built-in to Node.js and Deno"
+			},
 			{
 				value: "better-sqlite3",
-				hint: "for traditional Node environments"
+				hint: "for server environments"
 			},
 			{
 				value: "libsql",
@@ -6906,6 +6943,17 @@ var drizzle_default = defineAddon({
 					clientExpression = js.common.parseExpression(`createClient({ url: ${dbUrl}, authToken: ${dbToken} })`);
 				} else clientExpression = js.common.parseExpression(`createClient({ url: ${dbUrl} })`);
 			}
+			if (options.sqlite === "node-sqlite") {
+				js.imports.addNamed(ast, {
+					from: "node:sqlite",
+					imports: ["DatabaseSync"]
+				});
+				js.imports.addNamed(ast, {
+					from: "drizzle-orm/node-sqlite",
+					imports: ["drizzle"]
+				});
+				clientExpression = js.common.parseExpression(`new DatabaseSync(${dbUrl})`);
+			}
 			if (options.mysql === "mysql2" || options.mysql === "planetscale") {
 				js.imports.addDefault(ast, {
 					from: "mysql2/promise",
@@ -7008,7 +7056,11 @@ const generateEnv = (opts, isExample) => transforms.text(({ content, text }) =>
 	let value;
 	const comment = ["Drizzle"];
 	if (opts.docker) value = `"${opts.database === "mysql" ? "mysql" : "postgres"}://root:mysecretpassword@localhost:${PORTS[opts.database]}/local"`;
-	else if (opts.sqlite === "better-sqlite3" || opts.sqlite === "libsql") value = opts.sqlite === "libsql" ? "file:local.db" : "local.db";
+	else if ([
+		"better-sqlite3",
+		"libsql",
+		"node-sqlite"
+	].includes(opts.sqlite)) value = opts.sqlite === "libsql" ? "file:local.db" : "local.db";
 	else if (opts.sqlite === "turso") if (isExample) {
 		value = "\"libsql://db-name-user.turso.io\"";
 		comment.push("Replace with your DB credentials!", {
@@ -7189,50 +7241,16 @@ const FEATURES = {
 		path: "compilerOptions.experimental.async"
 	},
 	remoteFunctions: { label: "remote functions" },
-	explicitEnvironmentVariables: {
-		label: "explicit environment variables",
-		hint: "kit ^2 only",
-		inNext: false
-	},
-	handleRenderingErrors: {
-		label: "rendering error boundaries",
-		hint: "kit ^2 only",
-		inNext: false
-	},
 	forkPreloads: {
 		label: "forked preloading",
 		off: true
 	}
 };
-const SOURCE_EXTENSIONS = [
-	".svelte",
-	".svelte.ts",
-	".svelte.js",
-	".ts",
-	".js",
-	".svx",
-	".md"
-];
-const KIT3_PEERS = {
-	vite: "^8.0.0",
-	"@sveltejs/vite-plugin-svelte": "^7.0.0",
-	svelte: "^5.48.0",
-	typescript: "^6.0.0"
-};
 var experimental_default = defineAddon({
 	id: "experimental",
 	shortDescription: "svelte & kit experimental features",
 	homepage: "https://svelte.dev/docs/kit/configuration#experimental",
-	options: defineAddonOptions().add("versions", {
-		question: "Which packages should use their `next` (pre-release) version?",
-		type: "multiselect",
-		default: ["kit"],
-		options: [{
-			value: "kit",
-			label: "@sveltejs/kit@next"
-		}],
-		required: false
-	}).add("features", {
+	options: defineAddonOptions().add("features", {
 		question: "Which experimental features do you want to enable?",
 		type: "multiselect",
 		default: Object.entries(FEATURES).filter(([, f]) => !f.off).map(([value]) => value),
@@ -7243,44 +7261,10 @@ var experimental_default = defineAddon({
 		})),
 		required: false
 	}).build(),
-	setup: ({ runsAfter }) => runsAfter("sveltekitAdapter"),
-	run: ({ sv, cwd, options, language, directory, dependencyVersion }) => {
-		const kitNext = options.versions.includes("kit");
-		if (kitNext) {
-			sv.devDependency("@sveltejs/kit", "next");
-			for (const [pkg, range] of Object.entries(KIT3_PEERS)) {
-				if (pkg === "typescript" && language !== "ts") continue;
-				const current = dependencyVersion(pkg);
-				if (current && isVersionUnsupportedBelow(current, range)) sv.devDependency(pkg, range);
-			}
-			const { data: pkg } = loadPackageJson(cwd);
-			const deps = {
-				...pkg.devDependencies,
-				...pkg.dependencies
-			};
-			for (const name of Object.keys(deps)) if (name.startsWith("@sveltejs/adapter-")) sv.devDependency(name, "next");
-		}
-		if (kitNext) {
-			for (const name of ["tsconfig.json", "jsconfig.json"]) {
-				if (!fileExists(cwd, name)) continue;
-				sv.file(name, transforms.json(({ data }) => {
-					data.extends = KIT3_TSCONFIG;
-					data.include ??= [directory.src];
-					for (const [key, value] of Object.entries(data.compilerOptions ?? {})) if (KIT3_TSCONFIG_DEFAULT[key] === value) delete data.compilerOptions[key];
-				}));
-			}
-			sv.file("package.json", transforms.json(({ data }) => {
-				data.imports = {
-					...libSubpathImports(directory.lib),
-					...data.imports
-				};
-			}));
-			for (const relative of sourceFiles(cwd, directory.src)) sv.file(relative, (content) => content.includes("$lib") ? content.replaceAll("$lib", "#lib") : false);
-		}
+	run: ({ sv, cwd, options }) => {
 		const config = {};
 		for (const [name, f] of Object.entries(FEATURES)) {
 			if (!options.features.includes(name)) continue;
-			if (kitNext && f.inNext === false) continue;
 			const keys = (f.path ?? `experimental.${name}`).split(".");
 			let target = config;
 			for (const key of keys.slice(0, -1)) target = target[key] ??= {};
@@ -7292,12 +7276,6 @@ var experimental_default = defineAddon({
 		}, ({ override }) => override(config));
 	}
 });
-/** Workspace-relative source files under `src`, for the `$lib` -> `#lib` rewrite. */
-function sourceFiles(cwd, src) {
-	const root = path.resolve(cwd, src);
-	if (!fs.existsSync(root)) return [];
-	return fs.readdirSync(root, { recursive: true }).map((entry) => path.join(src, entry)).filter((relative) => SOURCE_EXTENSIONS.some((ext) => relative.endsWith(ext)) && fs.statSync(path.resolve(cwd, relative)).isFile());
-}
 //#endregion
 //#region src/addons/mdsvex.ts
 var mdsvex_default = defineAddon({
@@ -7425,8 +7403,7 @@ var paraglide_default = defineAddon({
 				language,
 				newHandleName: "handleParaglide",
 				handleContent: `({ event, resolve }) => paraglideMiddleware(event.request, ({ request, locale }) => {
-		event.request = request;
-		return resolve(event, {
+		return resolve({ ...event, request }, {
 			transformPageChunk: ({ html }) => html.replace('%paraglide.lang%', locale).replace('%paraglide.dir%', getTextDirection(locale))
 		});
 	});`,
@@ -8093,2711 +8070,1048 @@ function getAddonDetails(id) {
 	return details;
 }
 //#endregion
-//#region ../../node_modules/.pnpm/events-universal@1.0.1/node_modules/events-universal/default.js
-var require_default = /* @__PURE__ */ __commonJSMin(((exports, module) => {
-	module.exports = __require("events");
-}));
-//#endregion
-//#region ../../node_modules/.pnpm/fast-fifo@1.3.2/node_modules/fast-fifo/fixed-size.js
-var require_fixed_size = /* @__PURE__ */ __commonJSMin(((exports, module) => {
-	module.exports = class FixedFIFO {
-		constructor(hwm) {
-			if (!(hwm > 0) || (hwm - 1 & hwm) !== 0) throw new Error("Max size for a FixedFIFO should be a power of two");
-			this.buffer = new Array(hwm);
-			this.mask = hwm - 1;
-			this.top = 0;
-			this.btm = 0;
-			this.next = null;
-		}
-		clear() {
-			this.top = this.btm = 0;
-			this.next = null;
-			this.buffer.fill(void 0);
-		}
-		push(data) {
-			if (this.buffer[this.top] !== void 0) return false;
-			this.buffer[this.top] = data;
-			this.top = this.top + 1 & this.mask;
-			return true;
-		}
-		shift() {
-			const last = this.buffer[this.btm];
-			if (last === void 0) return void 0;
-			this.buffer[this.btm] = void 0;
-			this.btm = this.btm + 1 & this.mask;
-			return last;
-		}
-		peek() {
-			return this.buffer[this.btm];
-		}
-		isEmpty() {
-			return this.buffer[this.btm] === void 0;
+//#region ../../node_modules/.pnpm/modern-tar@0.7.7/node_modules/modern-tar/dist/packer-BtsuoKCV.js
+const FILE = "file";
+const LINK = "link";
+const SYMLINK = "symlink";
+const DIRECTORY = "directory";
+const FLAGTYPE = {
+	"0": FILE,
+	"1": LINK,
+	"2": SYMLINK,
+	"3": "character-device",
+	"4": "block-device",
+	"5": DIRECTORY,
+	"6": "fifo",
+	x: "pax-header",
+	g: "pax-global-header",
+	L: "gnu-long-name",
+	K: "gnu-long-link-name"
+};
+const EMPTY = /* @__PURE__ */ new Uint8Array(0);
+new TextEncoder();
+const decoder = new TextDecoder();
+function readString(view, offset, size) {
+	const end = view.indexOf(0, offset);
+	const sliceEnd = end === -1 || end > offset + size ? offset + size : end;
+	return decoder.decode(view.subarray(offset, sliceEnd));
+}
+function readOctal(view, offset, size) {
+	let value = 0;
+	const end = offset + size;
+	for (let i = offset; i < end; i++) {
+		const charCode = view[i];
+		if (charCode === 0) break;
+		if (charCode === 32) continue;
+		value = value * 8 + (charCode - 48);
+	}
+	return value;
+}
+function readNumeric(view, offset, size) {
+	if (view[offset] & 128) {
+		let result = 0;
+		result = view[offset] & 127;
+		for (let i = 1; i < size; i++) result = result * 256 + view[offset + i];
+		if (!Number.isSafeInteger(result)) throw new Error("TAR number too large");
+		return result;
+	}
+	return readOctal(view, offset, size);
+}
+const isBodyless = (header) => header.type === "directory" || header.type === "symlink" || header.type === "link" || header.type === "character-device" || header.type === "block-device" || header.type === "fifo";
+const stripPath = (p, n) => {
+	const parts = p.split("/").filter(Boolean);
+	return n >= parts.length ? "" : parts.slice(n).join("/");
+};
+function transformHeader(header, options) {
+	const { strip, filter, map } = options;
+	if (!strip && !filter && !map) return header;
+	const h = { ...header };
+	if (strip && strip > 0) {
+		const newName = stripPath(h.name, strip);
+		if (!newName) return null;
+		h.name = h.type === "directory" && !newName.endsWith("/") ? `${newName}/` : newName;
+		if (h.linkname) {
+			const isAbsolute = h.linkname.startsWith("/");
+			if (isAbsolute || h.type === "link") {
+				const stripped = stripPath(h.linkname, strip);
+				h.linkname = isAbsolute ? `/${stripped}` || "/" : stripped;
+			}
+		}
+	}
+	if (filter?.(h) === false) return null;
+	const result = map ? map(h) : h;
+	if (result && (!result.name || !result.name.trim() || result.name === "." || result.name === "/")) return null;
+	return result;
+}
+const INITIAL_CAPACITY = 256;
+function createChunkQueue() {
+	let chunks = new Array(INITIAL_CAPACITY);
+	let capacityMask = chunks.length - 1;
+	let head = 0;
+	let tail = 0;
+	let totalAvailable = 0;
+	const consumeFromHead = (count) => {
+		const chunk = chunks[head];
+		if (count === chunk.length) {
+			chunks[head] = EMPTY;
+			head = head + 1 & capacityMask;
+		} else chunks[head] = chunk.subarray(count);
+		totalAvailable -= count;
+		if (totalAvailable === 0 && chunks.length > INITIAL_CAPACITY) {
+			chunks = new Array(INITIAL_CAPACITY);
+			capacityMask = INITIAL_CAPACITY - 1;
+			head = 0;
+			tail = 0;
 		}
 	};
-}));
-//#endregion
-//#region ../../node_modules/.pnpm/fast-fifo@1.3.2/node_modules/fast-fifo/index.js
-var require_fast_fifo = /* @__PURE__ */ __commonJSMin(((exports, module) => {
-	const FixedFIFO = require_fixed_size();
-	module.exports = class FastFIFO {
-		constructor(hwm) {
-			this.hwm = hwm || 16;
-			this.head = new FixedFIFO(this.hwm);
-			this.tail = this.head;
-			this.length = 0;
+	function pull(bytes, callback) {
+		if (callback) {
+			let fed = 0;
+			let remaining = Math.min(bytes, totalAvailable);
+			while (remaining > 0) {
+				const chunk = chunks[head];
+				const toFeed = Math.min(remaining, chunk.length);
+				const segment = toFeed === chunk.length ? chunk : chunk.subarray(0, toFeed);
+				consumeFromHead(toFeed);
+				remaining -= toFeed;
+				fed += toFeed;
+				if (!callback(segment)) break;
+			}
+			return fed;
+		}
+		if (totalAvailable < bytes) return null;
+		if (bytes === 0) return EMPTY;
+		const firstChunk = chunks[head];
+		if (firstChunk.length >= bytes) {
+			const view = firstChunk.length === bytes ? firstChunk : firstChunk.subarray(0, bytes);
+			consumeFromHead(bytes);
+			return view;
+		}
+		const result = new Uint8Array(bytes);
+		let copied = 0;
+		let remaining = bytes;
+		while (remaining > 0) {
+			const chunk = chunks[head];
+			const toCopy = Math.min(remaining, chunk.length);
+			result.set(toCopy === chunk.length ? chunk : chunk.subarray(0, toCopy), copied);
+			copied += toCopy;
+			remaining -= toCopy;
+			consumeFromHead(toCopy);
 		}
-		clear() {
-			this.head = this.tail;
-			this.head.clear();
-			this.length = 0;
-		}
-		push(val) {
-			this.length++;
-			if (!this.head.push(val)) {
-				const prev = this.head;
-				this.head = prev.next = new FixedFIFO(2 * this.head.buffer.length);
-				this.head.push(val);
+		return result;
+	}
+	return {
+		push: (chunk) => {
+			if (chunk.length === 0) return;
+			let nextTail = tail + 1 & capacityMask;
+			if (nextTail === head) {
+				const oldLen = chunks.length;
+				const newLen = oldLen * 2;
+				const newChunks = new Array(newLen);
+				const count = tail - head + oldLen & oldLen - 1;
+				if (head < tail) for (let i = 0; i < count; i++) newChunks[i] = chunks[head + i];
+				else if (count > 0) {
+					const firstPart = oldLen - head;
+					for (let i = 0; i < firstPart; i++) newChunks[i] = chunks[head + i];
+					for (let i = 0; i < tail; i++) newChunks[firstPart + i] = chunks[i];
+				}
+				chunks = newChunks;
+				capacityMask = newLen - 1;
+				head = 0;
+				tail = count;
+				nextTail = tail + 1 & capacityMask;
+			}
+			chunks[tail] = chunk;
+			tail = nextTail;
+			totalAvailable += chunk.length;
+		},
+		available: () => totalAvailable,
+		peek: (bytes) => {
+			if (totalAvailable < bytes) return null;
+			if (bytes === 0) return EMPTY;
+			const firstChunk = chunks[head];
+			if (firstChunk.length >= bytes) return firstChunk.length === bytes ? firstChunk : firstChunk.subarray(0, bytes);
+			const result = new Uint8Array(bytes);
+			let copied = 0;
+			let index = head;
+			while (copied < bytes) {
+				const chunk = chunks[index];
+				const toCopy = Math.min(bytes - copied, chunk.length);
+				if (toCopy === chunk.length) result.set(chunk, copied);
+				else result.set(chunk.subarray(0, toCopy), copied);
+				copied += toCopy;
+				index = index + 1 & capacityMask;
 			}
-		}
-		shift() {
-			if (this.length !== 0) this.length--;
-			const val = this.tail.shift();
-			if (val === void 0 && this.tail.next) {
-				const next = this.tail.next;
-				this.tail.next = null;
-				this.tail = next;
-				return this.tail.shift();
+			return result;
+		},
+		discard: (bytes) => {
+			if (bytes > totalAvailable) throw new Error("Too many bytes consumed");
+			if (bytes === 0) return;
+			let remaining = bytes;
+			while (remaining > 0) {
+				const chunk = chunks[head];
+				const toConsume = Math.min(remaining, chunk.length);
+				consumeFromHead(toConsume);
+				remaining -= toConsume;
 			}
-			return val;
-		}
-		peek() {
-			const val = this.tail.peek();
-			if (val === void 0 && this.tail.next) return this.tail.next.peek();
-			return val;
-		}
-		isEmpty() {
-			return this.length === 0;
-		}
-	};
-}));
-//#endregion
-//#region ../../node_modules/.pnpm/b4a@1.8.1/node_modules/b4a/index.js
-var require_b4a = /* @__PURE__ */ __commonJSMin(((exports, module) => {
-	function isBuffer(value) {
-		return Buffer.isBuffer(value) || value instanceof Uint8Array;
-	}
-	function isEncoding(encoding) {
-		return Buffer.isEncoding(encoding);
-	}
-	function alloc(size, fill, encoding) {
-		return Buffer.alloc(size, fill, encoding);
-	}
-	function allocUnsafe(size) {
-		return Buffer.allocUnsafe(size);
-	}
-	function allocUnsafeSlow(size) {
-		return Buffer.allocUnsafeSlow(size);
-	}
-	function byteLength(string, encoding) {
-		return Buffer.byteLength(string, encoding);
-	}
-	function compare(a, b) {
-		return Buffer.compare(a, b);
-	}
-	function concat(buffers, totalLength) {
-		return Buffer.concat(buffers, totalLength);
-	}
-	function copy(source, target, targetStart, start, end) {
-		return toBuffer(source).copy(target, targetStart, start, end);
-	}
-	function equals(a, b) {
-		return toBuffer(a).equals(b);
-	}
-	function fill(buffer, value, offset, end, encoding) {
-		return toBuffer(buffer).fill(value, offset, end, encoding);
-	}
-	function from(value, encodingOrOffset, length) {
-		return Buffer.from(value, encodingOrOffset, length);
-	}
-	function includes(buffer, value, byteOffset, encoding) {
-		return toBuffer(buffer).includes(value, byteOffset, encoding);
-	}
-	function indexOf(buffer, value, byfeOffset, encoding) {
-		return toBuffer(buffer).indexOf(value, byfeOffset, encoding);
-	}
-	function lastIndexOf(buffer, value, byteOffset, encoding) {
-		return toBuffer(buffer).lastIndexOf(value, byteOffset, encoding);
-	}
-	function swap16(buffer) {
-		return toBuffer(buffer).swap16();
-	}
-	function swap32(buffer) {
-		return toBuffer(buffer).swap32();
-	}
-	function swap64(buffer) {
-		return toBuffer(buffer).swap64();
-	}
-	function toBuffer(buffer) {
-		if (Buffer.isBuffer(buffer)) return buffer;
-		return Buffer.from(buffer.buffer, buffer.byteOffset, buffer.byteLength);
-	}
-	function toString(buffer, encoding, start, end) {
-		return toBuffer(buffer).toString(encoding, start, end);
-	}
-	function write(buffer, string, offset, length, encoding) {
-		return toBuffer(buffer).write(string, offset, length, encoding);
-	}
-	function readDoubleBE(buffer, offset) {
-		return toBuffer(buffer).readDoubleBE(offset);
-	}
-	function readDoubleLE(buffer, offset) {
-		return toBuffer(buffer).readDoubleLE(offset);
-	}
-	function readFloatBE(buffer, offset) {
-		return toBuffer(buffer).readFloatBE(offset);
-	}
-	function readFloatLE(buffer, offset) {
-		return toBuffer(buffer).readFloatLE(offset);
-	}
-	function readInt32BE(buffer, offset) {
-		return toBuffer(buffer).readInt32BE(offset);
-	}
-	function readInt32LE(buffer, offset) {
-		return toBuffer(buffer).readInt32LE(offset);
-	}
-	function readUInt32BE(buffer, offset) {
-		return toBuffer(buffer).readUInt32BE(offset);
-	}
-	function readUInt32LE(buffer, offset) {
-		return toBuffer(buffer).readUInt32LE(offset);
-	}
-	function writeDoubleBE(buffer, value, offset) {
-		return toBuffer(buffer).writeDoubleBE(value, offset);
-	}
-	function writeDoubleLE(buffer, value, offset) {
-		return toBuffer(buffer).writeDoubleLE(value, offset);
-	}
-	function writeFloatBE(buffer, value, offset) {
-		return toBuffer(buffer).writeFloatBE(value, offset);
-	}
-	function writeFloatLE(buffer, value, offset) {
-		return toBuffer(buffer).writeFloatLE(value, offset);
-	}
-	function writeInt32BE(buffer, value, offset) {
-		return toBuffer(buffer).writeInt32BE(value, offset);
-	}
-	function writeInt32LE(buffer, value, offset) {
-		return toBuffer(buffer).writeInt32LE(value, offset);
-	}
-	function writeUInt32BE(buffer, value, offset) {
-		return toBuffer(buffer).writeUInt32BE(value, offset);
-	}
-	function writeUInt32LE(buffer, value, offset) {
-		return toBuffer(buffer).writeUInt32LE(value, offset);
-	}
-	module.exports = {
-		isBuffer,
-		isEncoding,
-		alloc,
-		allocUnsafe,
-		allocUnsafeSlow,
-		byteLength,
-		compare,
-		concat,
-		copy,
-		equals,
-		fill,
-		from,
-		includes,
-		indexOf,
-		lastIndexOf,
-		swap16,
-		swap32,
-		swap64,
-		toBuffer,
-		toString,
-		write,
-		readDoubleBE,
-		readDoubleLE,
-		readFloatBE,
-		readFloatLE,
-		readInt32BE,
-		readInt32LE,
-		readUInt32BE,
-		readUInt32LE,
-		writeDoubleBE,
-		writeDoubleLE,
-		writeFloatBE,
-		writeFloatLE,
-		writeInt32BE,
-		writeInt32LE,
-		writeUInt32BE,
-		writeUInt32LE
+		},
+		pull
 	};
-}));
-//#endregion
-//#region ../../node_modules/.pnpm/text-decoder@1.2.7/node_modules/text-decoder/lib/pass-through-decoder.js
-var require_pass_through_decoder = /* @__PURE__ */ __commonJSMin(((exports, module) => {
-	const b4a = require_b4a();
-	module.exports = class PassThroughDecoder {
-		constructor(encoding) {
-			this.encoding = encoding;
-		}
-		get remaining() {
-			return 0;
-		}
-		decode(data) {
-			return b4a.toString(data, this.encoding);
-		}
-		flush() {
-			return "";
-		}
+}
+const CHECKSUM_SPACE = 32;
+function validateChecksum(block) {
+	const stored = readOctal(block, 148, 8);
+	let sum = 0;
+	for (let i = 0; i < block.length; i++) if (i >= 148 && i < 156) sum += CHECKSUM_SPACE;
+	else sum += block[i];
+	return stored === sum;
+}
+function parseUstarHeader(block, strict) {
+	if (strict && !validateChecksum(block)) throw new Error("Invalid tar header checksum.");
+	const typeflag = readString(block, 156, 1);
+	const header = {
+		name: readString(block, 0, 100),
+		mode: readOctal(block, 100, 8),
+		uid: readNumeric(block, 108, 8),
+		gid: readNumeric(block, 116, 8),
+		size: readNumeric(block, 124, 12),
+		mtime: /* @__PURE__ */ new Date(readNumeric(block, 136, 12) * 1e3),
+		type: FLAGTYPE[typeflag] || "file",
+		linkname: readString(block, 157, 100)
 	};
-}));
-//#endregion
-//#region ../../node_modules/.pnpm/text-decoder@1.2.7/node_modules/text-decoder/lib/utf8-decoder.js
-var require_utf8_decoder = /* @__PURE__ */ __commonJSMin(((exports, module) => {
-	const b4a = require_b4a();
-	/**
-	* https://encoding.spec.whatwg.org/#utf-8-decoder
-	*/
-	module.exports = class UTF8Decoder {
-		constructor() {
-			this._reset();
-		}
-		get remaining() {
-			return this.bytesSeen;
-		}
-		decode(data) {
-			if (data.byteLength === 0) return "";
-			if (this.bytesNeeded === 0 && trailingIncomplete(data, 0) === 0) {
-				this.bytesSeen = trailingBytesSeen(data);
-				return b4a.toString(data, "utf8");
-			}
-			let result = "";
-			let start = 0;
-			if (this.bytesNeeded > 0) {
-				while (start < data.byteLength) {
-					const byte = data[start];
-					if (byte < this.lowerBoundary || byte > this.upperBoundary) {
-						result += "�";
-						this._reset();
-						break;
-					}
-					this.lowerBoundary = 128;
-					this.upperBoundary = 191;
-					this.codePoint = this.codePoint << 6 | byte & 63;
-					this.bytesSeen++;
-					start++;
-					if (this.bytesSeen === this.bytesNeeded) {
-						result += String.fromCodePoint(this.codePoint);
-						this._reset();
-						break;
+	const magic = readString(block, 257, 6);
+	if (magic.trim() === "ustar") {
+		header.uname = readString(block, 265, 32);
+		header.gname = readString(block, 297, 32);
+	}
+	if (magic === "ustar") header.prefix = readString(block, 345, 155);
+	return header;
+}
+const PAX_MAPPING = {
+	path: ["name", (v) => v],
+	linkpath: ["linkname", (v) => v],
+	size: ["size", (v) => /^\d+$/.test(v) && Number.isSafeInteger(+v) ? +v : NaN],
+	mtime: ["mtime", parseFloat],
+	uid: ["uid", (v) => parseInt(v, 10)],
+	gid: ["gid", (v) => parseInt(v, 10)],
+	uname: ["uname", (v) => v],
+	gname: ["gname", (v) => v]
+};
+function parsePax(buffer) {
+	const overrides = Object.create(null);
+	const pax = Object.create(null);
+	let isPax = false;
+	let offset = 0;
+	while (offset < buffer.length) {
+		const spaceIndex = buffer.indexOf(32, offset);
+		if (spaceIndex === -1) break;
+		const length = parseInt(decoder.decode(buffer.subarray(offset, spaceIndex)), 10);
+		if (!(length > 0)) break;
+		const recordEnd = offset + length;
+		const recordStr = decoder.decode(buffer.subarray(spaceIndex + 1, recordEnd - 1));
+		const equalsIndex = recordStr.indexOf("=");
+		if (equalsIndex > 0) {
+			const key = recordStr.slice(0, equalsIndex);
+			const value = recordStr.slice(equalsIndex + 1);
+			pax[key] = value;
+			isPax = true;
+			if (Object.hasOwn(PAX_MAPPING, key)) {
+				const [targetKey, parser] = PAX_MAPPING[key];
+				const parsedValue = parser(value);
+				if (typeof parsedValue === "string" || !Number.isNaN(parsedValue)) overrides[targetKey] = parsedValue;
+			}
+		}
+		offset = recordEnd;
+	}
+	if (isPax) overrides.pax = pax;
+	return overrides;
+}
+function applyOverrides(header, overrides) {
+	if (overrides.name !== void 0) header.name = overrides.name;
+	if (overrides.linkname !== void 0) header.linkname = overrides.linkname;
+	if (overrides.size !== void 0) header.size = overrides.size;
+	if (overrides.mtime !== void 0) header.mtime = /* @__PURE__ */ new Date(overrides.mtime * 1e3);
+	if (overrides.uid !== void 0) header.uid = overrides.uid;
+	if (overrides.gid !== void 0) header.gid = overrides.gid;
+	if (overrides.uname !== void 0) header.uname = overrides.uname;
+	if (overrides.gname !== void 0) header.gname = overrides.gname;
+	if (overrides.pax) header.pax = Object.assign({}, header.pax ?? {}, overrides.pax);
+}
+function getMetaParser(type) {
+	switch (type) {
+		case "pax-global-header":
+		case "pax-header": return parsePax;
+		case "gnu-long-name": return (data) => ({ name: readString(data, 0, data.length) });
+		case "gnu-long-link-name": return (data) => ({ linkname: readString(data, 0, data.length) });
+		default: return;
+	}
+}
+const STATE_HEADER = 0;
+const STATE_BODY = 1;
+const MAX_META_SIZE = 8 * 1024 * 1024;
+const truncateErr = /* @__PURE__ */ new Error("Tar archive is truncated.");
+function createUnpacker(options = {}) {
+	const strict = options.strict ?? false;
+	const { available, peek, push, discard, pull } = createChunkQueue();
+	let state = STATE_HEADER;
+	let ended = false;
+	let done = false;
+	let eof = false;
+	let currentEntry = null;
+	const paxGlobals = {};
+	let nextEntryOverrides = {};
+	const unpacker = {
+		isEntryActive: () => state === STATE_BODY,
+		isBodyComplete: () => !currentEntry || currentEntry.remaining === 0,
+		canFinish: () => !currentEntry || available() >= currentEntry.remaining + currentEntry.padding,
+		bodyBytes: () => currentEntry && currentEntry.remaining > 0 ? Math.min(currentEntry.remaining, available()) : 0,
+		write(chunk) {
+			if (ended) throw new Error("Archive already ended.");
+			push(chunk);
+		},
+		end() {
+			ended = true;
+		},
+		readHeader() {
+			if (state !== STATE_HEADER) throw new Error("Cannot read header while an entry is active");
+			if (done) return void 0;
+			while (!done) {
+				if (available() < 512) {
+					if (ended) {
+						if (available() > 0 && strict) throw truncateErr;
+						done = true;
+						return;
 					}
+					return null;
 				}
-				if (this.bytesNeeded > 0) return result;
-			}
-			const trailing = trailingIncomplete(data, start);
-			const end = data.byteLength - trailing;
-			if (end > start) result += b4a.toString(data, "utf8", start, end);
-			for (let i = end; i < data.byteLength; i++) {
-				const byte = data[i];
-				if (this.bytesNeeded === 0) {
-					if (byte <= 127) {
-						this.bytesSeen = 0;
-						result += String.fromCharCode(byte);
-					} else if (byte >= 194 && byte <= 223) {
-						this.bytesNeeded = 2;
-						this.bytesSeen = 1;
-						this.codePoint = byte & 31;
-					} else if (byte >= 224 && byte <= 239) {
-						if (byte === 224) this.lowerBoundary = 160;
-						else if (byte === 237) this.upperBoundary = 159;
-						this.bytesNeeded = 3;
-						this.bytesSeen = 1;
-						this.codePoint = byte & 15;
-					} else if (byte >= 240 && byte <= 244) {
-						if (byte === 240) this.lowerBoundary = 144;
-						else if (byte === 244) this.upperBoundary = 143;
-						this.bytesNeeded = 4;
-						this.bytesSeen = 1;
-						this.codePoint = byte & 7;
-					} else {
-						this.bytesSeen = 1;
-						result += "�";
+				const headerBlock = peek(512);
+				if (isZeroBlock(headerBlock)) {
+					if (available() < 512 * 2) {
+						if (ended) {
+							if (strict) throw truncateErr;
+							done = true;
+							return;
+						}
+						return null;
+					}
+					if (isZeroBlock(peek(512 * 2).subarray(512))) {
+						discard(512 * 2);
+						done = true;
+						eof = true;
+						return;
 					}
+					if (strict) throw new Error("Invalid tar header.");
+					discard(512);
 					continue;
 				}
-				if (byte < this.lowerBoundary || byte > this.upperBoundary) {
-					result += "�";
-					i--;
-					this._reset();
+				let internalHeader;
+				try {
+					internalHeader = parseUstarHeader(headerBlock, strict);
+				} catch (err) {
+					if (strict) throw err;
+					discard(512);
 					continue;
 				}
-				this.lowerBoundary = 128;
-				this.upperBoundary = 191;
-				this.codePoint = this.codePoint << 6 | byte & 63;
-				this.bytesSeen++;
-				if (this.bytesSeen === this.bytesNeeded) {
-					result += String.fromCodePoint(this.codePoint);
-					this._reset();
+				const metaParser = getMetaParser(internalHeader.type);
+				if (metaParser) {
+					if (internalHeader.size > MAX_META_SIZE) throw new Error("Tar metadata entry exceeds maximum size.");
+					const paddedSize = internalHeader.size + (-internalHeader.size & 511);
+					if (available() < 512 + paddedSize) {
+						if (ended && strict) throw truncateErr;
+						return null;
+					}
+					discard(512);
+					const overrides = metaParser(pull(paddedSize).subarray(0, internalHeader.size));
+					if (nextEntryOverrides.pax) nextEntryOverrides = {};
+					const target = internalHeader.type === "pax-global-header" ? paxGlobals : nextEntryOverrides;
+					for (const key in overrides) target[key] = overrides[key];
+					continue;
+				}
+				discard(512);
+				const header = internalHeader;
+				if (internalHeader.prefix) header.name = `${internalHeader.prefix}/${header.name}`;
+				applyOverrides(header, paxGlobals);
+				applyOverrides(header, nextEntryOverrides);
+				let archiveSize = header.size;
+				if (isBodyless(header)) {
+					archiveSize = 0;
+					header.size = 0;
+				} else if (header.name.endsWith("/") && header.type === "file") {
+					header.type = DIRECTORY;
+					header.size = 0;
+				}
+				nextEntryOverrides = {};
+				currentEntry = {
+					header,
+					remaining: archiveSize,
+					padding: -archiveSize & 511
+				};
+				state = STATE_BODY;
+				return header;
+			}
+		},
+		streamBody(callback) {
+			if (state !== STATE_BODY || !currentEntry || currentEntry.remaining === 0) return 0;
+			const bytesToFeed = Math.min(currentEntry.remaining, available());
+			if (bytesToFeed === 0) return 0;
+			const fed = pull(bytesToFeed, callback);
+			currentEntry.remaining -= fed;
+			return fed;
+		},
+		skipPadding() {
+			if (state !== STATE_BODY || !currentEntry) return true;
+			if (currentEntry.remaining > 0) throw new Error("Body not fully consumed");
+			if (available() < currentEntry.padding) return false;
+			discard(currentEntry.padding);
+			currentEntry = null;
+			state = STATE_HEADER;
+			return true;
+		},
+		skipEntry() {
+			if (state !== STATE_BODY || !currentEntry) return true;
+			const toDiscard = Math.min(currentEntry.remaining, available());
+			if (toDiscard > 0) {
+				discard(toDiscard);
+				currentEntry.remaining -= toDiscard;
+			}
+			if (currentEntry.remaining > 0) return false;
+			return unpacker.skipPadding();
+		},
+		validateEOF() {
+			if (strict) {
+				if (!eof) throw truncateErr;
+				if (available() > 0) {
+					if (pull(available()).some((byte) => byte !== 0)) throw new Error("Invalid EOF.");
 				}
 			}
-			return result;
-		}
-		flush() {
-			const result = this.bytesNeeded > 0 ? "�" : "";
-			this._reset();
-			return result;
-		}
-		_reset() {
-			this.codePoint = 0;
-			this.bytesNeeded = 0;
-			this.bytesSeen = 0;
-			this.lowerBoundary = 128;
-			this.upperBoundary = 191;
 		}
 	};
-	function trailingIncomplete(data, start) {
-		const len = data.byteLength;
-		if (len <= start) return 0;
-		const limit = Math.max(start, len - 4);
-		let i = len - 1;
-		while (i > limit && (data[i] & 192) === 128) i--;
-		if (i < start) return 0;
-		const byte = data[i];
-		let needed;
-		if (byte <= 127) return 0;
-		if (byte >= 194 && byte <= 223) needed = 2;
-		else if (byte >= 224 && byte <= 239) needed = 3;
-		else if (byte >= 240 && byte <= 244) needed = 4;
-		else return 0;
-		const available = len - i;
-		return available < needed ? available : 0;
-	}
-	function trailingBytesSeen(data) {
-		const len = data.byteLength;
-		if (len === 0) return 0;
-		const last = data[len - 1];
-		if (last <= 127) return 0;
-		if ((last & 192) !== 128) return 1;
-		const limit = Math.max(0, len - 4);
-		let i = len - 2;
-		while (i >= limit && (data[i] & 192) === 128) i--;
-		if (i < 0) return 1;
-		const first = data[i];
-		let needed;
-		if (first >= 194 && first <= 223) needed = 2;
-		else if (first >= 224 && first <= 239) needed = 3;
-		else if (first >= 240 && first <= 244) needed = 4;
-		else return 1;
-		if (len - i !== needed) return 1;
-		if (needed >= 3) {
-			const second = data[i + 1];
-			if (first === 224 && second < 160) return 1;
-			if (first === 237 && second > 159) return 1;
-			if (first === 240 && second < 144) return 1;
-			if (first === 244 && second > 143) return 1;
-		}
-		return 0;
-	}
-}));
+	return unpacker;
+}
+function isZeroBlock(block) {
+	if (block.byteOffset % 8 === 0) {
+		const view = new BigUint64Array(block.buffer, block.byteOffset, block.length / 8);
+		for (let i = 0; i < view.length; i++) if (view[i] !== 0n) return false;
+		return true;
+	}
+	for (let i = 0; i < block.length; i++) if (block[i] !== 0) return false;
+	return true;
+}
 //#endregion
-//#region ../../node_modules/.pnpm/text-decoder@1.2.7/node_modules/text-decoder/index.js
-var require_text_decoder = /* @__PURE__ */ __commonJSMin(((exports, module) => {
-	const PassThroughDecoder = require_pass_through_decoder();
-	const UTF8Decoder = require_utf8_decoder();
-	module.exports = class TextDecoder {
-		constructor(encoding = "utf8") {
-			this.encoding = normalizeEncoding(encoding);
-			switch (this.encoding) {
-				case "utf8":
-					this.decoder = new UTF8Decoder();
-					break;
-				case "utf16le":
-				case "base64": throw new Error("Unsupported encoding: " + this.encoding);
-				default: this.decoder = new PassThroughDecoder(this.encoding);
-			}
-		}
-		get remaining() {
-			return this.decoder.remaining;
-		}
-		push(data) {
-			if (typeof data === "string") return data;
-			return this.decoder.decode(data);
-		}
-		write(data) {
-			return this.push(data);
+//#region ../../node_modules/.pnpm/modern-tar@0.7.7/node_modules/modern-tar/dist/fs/index.js
+function validateBounds(targetPath, destDir, errorMessage) {
+	const target = path$1.resolve(targetPath);
+	const dest = path$1.resolve(destDir);
+	if (target !== dest && !target.startsWith(dest + path$1.sep)) throw new Error(errorMessage);
+}
+const win32Reserved = {
+	":": "",
+	"<": "",
+	">": "",
+	"|": "",
+	"?": "",
+	"*": "",
+	"\"": ""
+};
+function normalizeName(name) {
+	const path = name.replace(/\\/g, "/");
+	if (path.split("/").includes("..") || /^[a-zA-Z]:\.\./.test(path)) throw new Error(`${name} points outside extraction directory`);
+	let relative = path;
+	if (/^[a-zA-Z]:/.test(relative)) relative = relative.replace(/^[a-zA-Z]:[/\\]?/, "");
+	else if (relative.startsWith("/")) relative = relative.replace(/^\/+/, "");
+	if (process.platform === "win32") return relative.replace(/[<>:"|?*]/g, (char) => win32Reserved[char]);
+	return relative;
+}
+const normalizeHeaderName = (s) => normalizeName(s.replace(/\/+$/, ""));
+const createOperationQueue = (concurrency) => {
+	let active = 0;
+	const tasks = [];
+	let head = 0;
+	let idle = null;
+	let resolveIdle = null;
+	const ensureIdle = () => idle ??= new Promise((resolve) => resolveIdle = resolve);
+	const flush = () => {
+		while (active < concurrency && head < tasks.length) {
+			const task = tasks[head++];
+			active++;
+			task().finally(() => {
+				active--;
+				flush();
+			});
 		}
-		end(data) {
-			let result = "";
-			if (data) result = this.push(data);
-			result += this.decoder.flush();
-			return result;
+		if (head === tasks.length) {
+			tasks.length = 0;
+			head = 0;
+			if (active === 0 && resolveIdle) {
+				resolveIdle();
+				idle = null;
+				resolveIdle = null;
+			}
 		}
 	};
-	function normalizeEncoding(encoding) {
-		encoding = encoding.toLowerCase();
-		switch (encoding) {
-			case "utf8":
-			case "utf-8": return "utf8";
-			case "ucs2":
-			case "ucs-2":
-			case "utf16le":
-			case "utf-16le": return "utf16le";
-			case "latin1":
-			case "binary": return "latin1";
-			case "base64":
-			case "ascii":
-			case "hex": return encoding;
-			default: throw new Error("Unknown encoding: " + encoding);
-		}
-	}
-}));
-//#endregion
-//#region ../../node_modules/.pnpm/streamx@2.26.0/node_modules/streamx/lib/errors.js
-var require_errors = /* @__PURE__ */ __commonJSMin(((exports, module) => {
-	module.exports = class StreamError extends Error {
-		constructor(msg, code, fn = StreamError) {
-			super(msg);
-			this.code = code;
-			if (Error.captureStackTrace) Error.captureStackTrace(this, fn);
+	return {
+		add(op) {
+			const wasIdle = active === 0 && head === tasks.length;
+			return new Promise((resolve, reject) => {
+				tasks.push(() => Promise.resolve().then(op).then(resolve, reject));
+				if (wasIdle) ensureIdle();
+				flush();
+			});
+		},
+		onIdle() {
+			return active === 0 && head === tasks.length ? Promise.resolve() : ensureIdle();
 		}
-		static isStreamDestroyed(err) {
-			return err && err.code === "STREAM_DESTROYED";
+	};
+};
+const BATCH_BYTES = 256 * 1024;
+const CREATE_FLAGS = fs$1.constants.O_WRONLY | fs$1.constants.O_CREAT | fs$1.constants.O_TRUNC | (fs$1.constants.O_NOFOLLOW ?? 0) | fs$1.constants.O_EXCL;
+const STATE_OPENING = 1;
+const STATE_OPEN = 2;
+const STATE_CLOSED = 3;
+const STATE_FAILED = 4;
+const DRAINED_PROMISE = Promise.resolve();
+function createFileSink(path, { mode = 438, mtime } = {}) {
+	let state = STATE_OPENING;
+	let flushing = false;
+	let fd = null;
+	let queue = [];
+	let spare = [];
+	let bytes = 0;
+	let storedError = null;
+	let endPromise = null;
+	let endResolve = null;
+	let endReject = null;
+	const waitResolves = [];
+	const waitRejects = [];
+	const settleWaiters = () => {
+		if (waitResolves.length === 0) return;
+		for (let i = 0; i < waitResolves.length; i++) waitResolves[i]();
+		waitResolves.length = 0;
+		waitRejects.length = 0;
+	};
+	const failWaiters = (error) => {
+		if (waitRejects.length === 0) return;
+		for (let i = 0; i < waitRejects.length; i++) waitRejects[i](error);
+		waitRejects.length = 0;
+		waitResolves.length = 0;
+	};
+	const resetBuffers = () => {
+		bytes = 0;
+		queue.length = 0;
+		spare.length = 0;
+	};
+	const finish = () => {
+		state = STATE_CLOSED;
+		endResolve?.();
+		settleWaiters();
+	};
+	const swapQueues = () => {
+		const current = queue;
+		queue = spare;
+		spare = current;
+		queue.length = 0;
+		return current;
+	};
+	const fail = (error) => {
+		if (storedError) return;
+		storedError = error;
+		state = STATE_FAILED;
+		resetBuffers();
+		flushing = false;
+		const fdToClose = fd;
+		fd = null;
+		if (fdToClose !== null) fs$1.ftruncate(fdToClose, 0, () => fs$1.close(fdToClose));
+		endReject?.(error);
+		failWaiters(error);
+	};
+	const close = () => {
+		if (fd === null) {
+			finish();
+			return;
 		}
-		static isPrematureClose(err) {
-			return err && err.code === "PREMATURE_CLOSE";
+		const fdToClose = fd;
+		fd = null;
+		if (mtime) fs$1.futimes(fdToClose, mtime, mtime, (err) => {
+			if (err) return fail(err);
+			fs$1.close(fdToClose, (closeErr) => {
+				if (closeErr) fail(closeErr);
+				else finish();
+			});
+		});
+		else fs$1.close(fdToClose, (err) => {
+			if (err) fail(err);
+			else finish();
+		});
+	};
+	const flush = () => {
+		if (flushing || queue.length === 0 || state !== STATE_OPEN) return;
+		flushing = true;
+		const bufs = swapQueues();
+		const onDone = (err, written = 0) => {
+			if (err) return fail(err);
+			flushing = false;
+			bytes -= written;
+			spare.length = 0;
+			if (bytes < BATCH_BYTES) settleWaiters();
+			if (queue.length > 0) flush();
+			else if (endResolve) close();
+		};
+		if (bufs.length === 1) {
+			const buf = bufs[0];
+			fs$1.write(fd, buf, 0, buf.length, null, onDone);
+		} else fs$1.writev(fd, bufs, onDone);
+	};
+	const onOpen = (err, openFd) => {
+		if (err) return fail(err);
+		if (state === STATE_CLOSED || state === STATE_FAILED) {
+			fs$1.close(openFd);
+			return;
 		}
-		static isAborted(err) {
-			return err && err.code === "ABORTED";
+		fd = openFd;
+		state = STATE_OPEN;
+		if (endResolve) if (queue.length > 0) flush();
+		else close();
+		else if (bytes >= BATCH_BYTES && !flushing) flush();
+		else settleWaiters();
+	};
+	const write = (chunk) => {
+		if (storedError || state >= STATE_CLOSED || endResolve) return false;
+		const buf = Buffer.isBuffer(chunk) ? chunk : chunk instanceof Uint8Array ? Buffer.from(chunk.buffer, chunk.byteOffset, chunk.byteLength) : Buffer.from(chunk);
+		if (buf.length === 0) return bytes < BATCH_BYTES;
+		queue.push(buf);
+		bytes += buf.length;
+		if (state === STATE_OPEN && !flushing && bytes >= BATCH_BYTES) flush();
+		return bytes < BATCH_BYTES;
+	};
+	const waitDrain = () => {
+		if (state === STATE_OPENING || state === STATE_OPEN && bytes >= BATCH_BYTES) return new Promise((resolve, reject) => {
+			waitResolves.push(resolve);
+			waitRejects.push(reject);
+		});
+		return DRAINED_PROMISE;
+	};
+	const end = () => {
+		if (state >= STATE_CLOSED) return DRAINED_PROMISE;
+		if (storedError) return Promise.reject(storedError);
+		if (endPromise) return endPromise;
+		endPromise = new Promise((resolve, reject) => {
+			endResolve = resolve;
+			endReject = reject;
+			if (state === STATE_OPEN && !flushing) if (queue.length > 0) flush();
+			else close();
+		});
+		return endPromise;
+	};
+	const destroy = (error) => {
+		if (error) {
+			fail(error);
+			return;
 		}
-		get name() {
-			return "StreamError";
+		if (state >= STATE_CLOSED || storedError) return;
+		resetBuffers();
+		flushing = false;
+		if (fd !== null) {
+			const fdToClose = fd;
+			fd = null;
+			fs$1.close(fdToClose);
 		}
-		static STREAM_DESTROYED() {
-			return new StreamError("Stream was destroyed", "STREAM_DESTROYED", StreamError.STREAM_DESTROYED);
+		finish();
+	};
+	fs$1.open(path, CREATE_FLAGS, mode, (err, openFd) => {
+		if (!err || err.code !== "EEXIST") return onOpen(err, openFd);
+		fs$1.rm(path, { force: true }, (rmErr) => {
+			if (rmErr) return fail(rmErr);
+			fs$1.open(path, CREATE_FLAGS, mode, onOpen);
+		});
+	});
+	return {
+		write,
+		end,
+		destroy,
+		waitDrain
+	};
+}
+const createCache = () => {
+	const m = /* @__PURE__ */ new Map();
+	return {
+		get(k) {
+			const v = m.get(k);
+			if (m.delete(k)) m.set(k, v);
+			return v;
+		},
+		set(k, v) {
+			if (m.set(k, v).size > 1e4) m.delete(m.keys().next().value);
+		},
+		clear() {
+			m.clear();
 		}
-		static PREMATURE_CLOSE() {
-			return new StreamError("Premature close", "PREMATURE_CLOSE", StreamError.PREMATURE_CLOSE);
+	};
+};
+const ENOENT = "ENOENT";
+const MAX_SYMLINKS = 64;
+const linkSep = process.platform === "win32" ? /[/\\]/ : "/";
+const linkParts = (linkname) => linkname.split(linkSep).filter((part) => part && part !== ".");
+const createPathCache = (destDirPath, options, opQueue, concurrency) => {
+	const { maxDepth = 1024, dmode } = options;
+	const dirPromises = createCache();
+	const pathConflicts = /* @__PURE__ */ new Map();
+	const deferredLinks = [];
+	let symlinks;
+	const realDirCache = createCache();
+	const initializeDestDir = async (destDirPath) => {
+		const symbolic = path$1.resolve(destDirPath);
+		try {
+			await fsp.mkdir(symbolic, { recursive: true });
+		} catch (err) {
+			if (err.code === ENOENT) {
+				const parentDir = path$1.dirname(symbolic);
+				if (parentDir === symbolic) throw err;
+				await fsp.mkdir(parentDir, { recursive: true });
+				await fsp.mkdir(symbolic, { recursive: true });
+			} else throw err;
 		}
-		static ABORTED() {
-			return new StreamError("Stream aborted", "ABORTED", StreamError.ABORTED);
+		try {
+			return {
+				symbolic,
+				real: await fsp.realpath(symbolic)
+			};
+		} catch (err) {
+			if (err.code === ENOENT) return {
+				symbolic,
+				real: symbolic
+			};
+			throw err;
 		}
 	};
-}));
-//#endregion
-//#region ../../node_modules/.pnpm/streamx@2.26.0/node_modules/streamx/index.js
-var require_streamx = /* @__PURE__ */ __commonJSMin(((exports, module) => {
-	const { EventEmitter } = require_default();
-	const FIFO = require_fast_fifo();
-	const TextDecoder = require_text_decoder();
-	const StreamError = require_errors();
-	const qmt = typeof queueMicrotask === "undefined" ? (fn) => global.process.nextTick(fn) : queueMicrotask;
-	const OPENING = 1;
-	const PREDESTROYING = 2;
-	const DESTROYING = 4;
-	const DESTROYED = 8;
-	const NOT_OPENING = 536870910;
-	const NOT_PREDESTROYING = 536870909;
-	const READ_UPDATING = 32;
-	const READ_PRIMARY = 64;
-	const READ_QUEUED = 128;
-	const READ_RESUMED = 256;
-	const READ_PIPE_DRAINED = 512;
-	const READ_ENDING = 1024;
-	const READ_EMIT_DATA = 2048;
-	const READ_EMIT_READABLE = 4096;
-	const READ_EMITTED_READABLE = 8192;
-	const READ_DONE = 16384;
-	const READ_NEXT_TICK = 32768;
-	const READ_READ_AHEAD = 131072;
-	const READ_FLOWING = 768;
-	const READ_ACTIVE_AND_NEEDS_PUSH = 65552;
-	const READ_PRIMARY_AND_ACTIVE = 80;
-	const READ_EMIT_READABLE_AND_QUEUED = 4224;
-	const READ_RESUMED_READ_AHEAD = 131328;
-	const READ_NOT_ACTIVE = 536870895;
-	const READ_NON_PRIMARY_AND_PUSHED = 536805311;
-	const READ_PUSHED = 536805375;
-	const READ_PAUSED = 536870655;
-	const READ_NOT_QUEUED = 536862591;
-	const READ_NOT_ENDING = 536869887;
-	const READ_PIPE_NOT_DRAINED = 536870143;
-	const READ_NOT_NEXT_TICK = 536838143;
-	const READ_NOT_UPDATING = 536870879;
-	const READ_NO_READ_AHEAD = 536739839;
-	const READ_PAUSED_NO_READ_AHEAD = 536739583;
-	const WRITE_ACTIVE = 1 << 18;
-	const WRITE_UPDATING = 2 << 18;
-	const WRITE_PRIMARY = 4 << 18;
-	const WRITE_QUEUED = 8 << 18;
-	const WRITE_UNDRAINED = 16 << 18;
-	const WRITE_DONE = 32 << 18;
-	const WRITE_EMIT_DRAIN = 64 << 18;
-	const WRITE_NEXT_TICK = 128 << 18;
-	const WRITE_WRITING = 256 << 18;
-	const WRITE_FINISHING = 512 << 18;
-	const WRITE_CORKED = 1024 << 18;
-	const WRITE_NOT_ACTIVE = 469499903;
-	const WRITE_NON_PRIMARY = 535822335;
-	const WRITE_NOT_FINISHING = 402391039;
-	const WRITE_DRAINED = 532676607;
-	const WRITE_NOT_QUEUED = 534773759;
-	const WRITE_NOT_NEXT_TICK = 503316479;
-	const WRITE_NOT_UPDATING = 536346623;
-	const WRITE_NOT_CORKED = 268435455;
-	const ACTIVE = 262160;
-	const NOT_ACTIVE = 536608751;
-	const DONE = 8404992;
-	const DESTROY_STATUS = 14;
-	const OPEN_STATUS = 15;
-	const AUTO_DESTROY = 8405006;
-	const NON_PRIMARY = 535822271;
-	const ACTIVE_OR_TICKING = 33587200;
-	const IS_OPENING = 33587215;
-	const READ_PRIMARY_STATUS = 17423;
-	const READ_STATUS = 16527;
-	const READ_ENDING_STATUS = 1167;
-	const READ_READABLE_STATUS = 12431;
-	const SHOULD_NOT_READ = 214047;
-	const READ_BACKPRESSURE_STATUS = 17422;
-	const READ_UPDATE_SYNC_STATUS = 32879;
-	const READ_NEXT_TICK_OR_OPENING = 32769;
-	const WRITE_PRIMARY_STATUS = 142606351;
-	const WRITE_QUEUED_AND_UNDRAINED = 6291456;
-	const WRITE_QUEUED_AND_ACTIVE = 2359296;
-	const WRITE_DRAIN_STATUS = 6553615;
-	const WRITE_STATUS = 270794767;
-	const WRITE_PRIMARY_AND_ACTIVE = 1310720;
-	const WRITE_ACTIVE_AND_WRITING = 67371008;
-	const WRITE_FINISHING_STATUS = 144965647;
-	const WRITE_BACKPRESSURE_STATUS = 146800654;
-	const WRITE_UPDATE_SYNC_STATUS = 35127311;
-	const WRITE_DROP_DATA = 142606350;
-	const asyncIterator = Symbol.asyncIterator || Symbol("asyncIterator");
-	var WritableState = class {
-		constructor(stream, { highWaterMark = 16384, map = null, mapWritable, byteLength, byteLengthWritable } = {}) {
-			this.stream = stream;
-			this.queue = new FIFO();
-			this.highWaterMark = highWaterMark;
-			this.buffered = 0;
-			this.error = null;
-			this.pipeline = null;
-			this.drains = null;
-			this.byteLength = byteLengthWritable || byteLength || defaultByteLength;
-			this.map = mapWritable || map;
-			this.afterWrite = afterWrite.bind(this);
-			this.afterUpdateNextTick = updateWriteNT.bind(this);
-		}
-		get ending() {
-			return (this.stream._duplexState & WRITE_FINISHING) !== 0;
-		}
-		get ended() {
-			return (this.stream._duplexState & WRITE_DONE) !== 0;
-		}
-		push(data) {
-			if ((this.stream._duplexState & WRITE_DROP_DATA) !== 0) return false;
-			if (this.map !== null) data = this.map(data);
-			this.buffered += this.byteLength(data);
-			this.queue.push(data);
-			if (this.buffered < this.highWaterMark) {
-				this.stream._duplexState |= WRITE_QUEUED;
-				return true;
-			}
-			this.stream._duplexState |= WRITE_QUEUED_AND_UNDRAINED;
-			return false;
+	const destDirPromise = initializeDestDir(destDirPath);
+	destDirPromise.catch(() => {});
+	const getRealDir = async (dirPath, errorMessage) => {
+		const destDir = await destDirPromise;
+		if (dirPath === destDir.symbolic) return destDir.real;
+		let promise = realDirCache.get(dirPath);
+		if (!promise) {
+			promise = fsp.realpath(dirPath).then((realPath) => {
+				validateBounds(realPath, destDir.real, errorMessage);
+				return realPath;
+			});
+			realDirCache.set(dirPath, promise);
 		}
-		shift() {
-			const data = this.queue.shift();
-			this.buffered -= this.byteLength(data);
-			if (this.buffered === 0) this.stream._duplexState &= WRITE_NOT_QUEUED;
-			return data;
-		}
-		end(data) {
-			if (typeof data === "function") this.stream.once("finish", data);
-			else if (data !== void 0 && data !== null) this.push(data);
-			this.stream._duplexState = (this.stream._duplexState | WRITE_FINISHING) & WRITE_NON_PRIMARY;
-		}
-		autoBatch(data, cb) {
-			const buffer = [];
-			const stream = this.stream;
-			buffer.push(data);
-			while ((stream._duplexState & WRITE_STATUS) === WRITE_QUEUED_AND_ACTIVE) buffer.push(stream._writableState.shift());
-			if ((stream._duplexState & OPEN_STATUS) !== 0) return cb(null);
-			stream._writev(buffer, cb);
-		}
-		update() {
-			const stream = this.stream;
-			stream._duplexState |= WRITE_UPDATING;
-			do {
-				while ((stream._duplexState & WRITE_STATUS) === WRITE_QUEUED) {
-					const data = this.shift();
-					stream._duplexState |= WRITE_ACTIVE_AND_WRITING;
-					stream._write(data, this.afterWrite);
+		return promise;
+	};
+	const prepareDirectory = async (dirPath, mode) => {
+		let promise = dirPromises.get(dirPath);
+		if (promise) return promise;
+		promise = (async () => {
+			if (dirPath === (await destDirPromise).symbolic) return;
+			await prepareDirectory(path$1.dirname(dirPath));
+			try {
+				const stat = await fsp.lstat(dirPath);
+				if (stat.isDirectory()) return;
+				if (stat.isSymbolicLink()) try {
+					const realPath = await getRealDir(dirPath, `Symlink "${dirPath}" points outside the extraction directory.`);
+					if ((await fsp.stat(realPath)).isDirectory()) return;
+				} catch (err) {
+					if (err.code === ENOENT) throw new Error(`Symlink "${dirPath}" points outside the extraction directory.`);
+					throw err;
 				}
-				if ((stream._duplexState & WRITE_PRIMARY_AND_ACTIVE) === 0) this.updateNonPrimary();
-			} while (this.continueUpdate() === true);
-			stream._duplexState &= WRITE_NOT_UPDATING;
-		}
-		updateNonPrimary() {
-			const stream = this.stream;
-			if ((stream._duplexState & WRITE_FINISHING_STATUS) === WRITE_FINISHING) {
-				stream._duplexState = stream._duplexState | WRITE_ACTIVE;
-				stream._final(afterFinal.bind(this));
-				return;
-			}
-			if ((stream._duplexState & DESTROY_STATUS) === DESTROYING) {
-				if ((stream._duplexState & ACTIVE_OR_TICKING) === 0) {
-					stream._duplexState |= ACTIVE;
-					stream._destroy(afterDestroy.bind(this));
+				throw new Error(`"${dirPath}" is not a valid directory component.`);
+			} catch (err) {
+				if (err.code === ENOENT) {
+					await fsp.mkdir(dirPath, { mode: mode ?? options.dmode });
+					return;
 				}
-				return;
-			}
-			if ((stream._duplexState & IS_OPENING) === OPENING) {
-				stream._duplexState = (stream._duplexState | ACTIVE) & NOT_OPENING;
-				stream._open(afterOpen.bind(this));
+				throw err;
 			}
-		}
-		continueUpdate() {
-			if ((this.stream._duplexState & WRITE_NEXT_TICK) === 0) return false;
-			this.stream._duplexState &= WRITE_NOT_NEXT_TICK;
-			return true;
-		}
-		updateCallback() {
-			if ((this.stream._duplexState & WRITE_UPDATE_SYNC_STATUS) === WRITE_PRIMARY) this.update();
-			else this.updateNextTick();
-		}
-		updateNextTick() {
-			if ((this.stream._duplexState & WRITE_NEXT_TICK) !== 0) return;
-			this.stream._duplexState |= WRITE_NEXT_TICK;
-			if ((this.stream._duplexState & WRITE_UPDATING) === 0) qmt(this.afterUpdateNextTick);
-		}
+		})();
+		dirPromises.set(dirPath, promise);
+		return promise;
 	};
-	var ReadableState = class {
-		constructor(stream, { highWaterMark = 16384, map = null, mapReadable, byteLength, byteLengthReadable } = {}) {
-			this.stream = stream;
-			this.queue = new FIFO();
-			this.highWaterMark = highWaterMark === 0 ? 1 : highWaterMark;
-			this.buffered = 0;
-			this.readAhead = highWaterMark > 0;
-			this.error = null;
-			this.pipeline = null;
-			this.byteLength = byteLengthReadable || byteLength || defaultByteLength;
-			this.map = mapReadable || map;
-			this.pipeTo = null;
-			this.afterRead = afterRead.bind(this);
-			this.afterUpdateNextTick = updateReadNT.bind(this);
-		}
-		get ending() {
-			return (this.stream._duplexState & READ_ENDING) !== 0;
-		}
-		get ended() {
-			return (this.stream._duplexState & READ_DONE) !== 0;
-		}
-		pipe(pipeTo, cb) {
-			if (this.pipeTo !== null) throw new Error("Can only pipe to one destination");
-			if (typeof cb !== "function") cb = null;
-			this.stream._duplexState |= READ_PIPE_DRAINED;
-			this.pipeTo = pipeTo;
-			this.pipeline = new Pipeline(this.stream, pipeTo, cb);
-			if (cb) this.stream.on("error", noop);
-			if (isStreamx(pipeTo)) {
-				pipeTo._writableState.pipeline = this.pipeline;
-				if (cb) pipeTo.on("error", noop);
-				pipeTo.on("finish", this.pipeline.finished.bind(this.pipeline));
-			} else {
-				const onerror = this.pipeline.done.bind(this.pipeline, pipeTo);
-				const onclose = this.pipeline.done.bind(this.pipeline, pipeTo, null);
-				pipeTo.on("error", onerror);
-				pipeTo.on("close", onclose);
-				pipeTo.on("finish", this.pipeline.finished.bind(this.pipeline));
-			}
-			pipeTo.on("drain", afterDrain.bind(this));
-			this.stream.emit("piping", pipeTo);
-			pipeTo.emit("pipe", this.stream);
-		}
-		push(data) {
-			const stream = this.stream;
-			if (data === null) {
-				this.highWaterMark = 0;
-				stream._duplexState = (stream._duplexState | READ_ENDING) & READ_NON_PRIMARY_AND_PUSHED;
-				return false;
+	return {
+		async ready() {
+			await destDirPromise;
+		},
+		async preparePath(header) {
+			const { name, linkname, type, mode, mtime } = header;
+			const normalizedName = normalizeHeaderName(name);
+			const destDir = await destDirPromise;
+			const outPath = path$1.join(destDir.symbolic, normalizedName);
+			if (maxDepth !== Infinity) {
+				let depth = 1;
+				for (const char of normalizedName) if (char === "/" && ++depth > maxDepth) throw new Error("Tar exceeds max specified depth.");
+			}
+			const prevOp = pathConflicts.get(normalizedName);
+			if (prevOp) {
+				if (prevOp === "directory" && type !== "directory" || prevOp !== "directory" && type === "directory") throw new Error(`Path conflict ${type} over existing ${prevOp} at "${name}"`);
+				return;
 			}
-			if (this.map !== null) {
-				data = this.map(data);
-				if (data === null) {
-					stream._duplexState &= READ_PUSHED;
-					return this.buffered < this.highWaterMark;
+			const parentDir = path$1.dirname(outPath);
+			switch (type) {
+				case DIRECTORY: {
+					pathConflicts.set(normalizedName, DIRECTORY);
+					const safeMode = mode ? mode & 511 : void 0;
+					await prepareDirectory(outPath, dmode ?? safeMode);
+					if (mtime) await fsp.lutimes(outPath, mtime, mtime).catch(() => {});
+					return;
 				}
-			}
-			this.buffered += this.byteLength(data);
-			this.queue.push(data);
-			stream._duplexState = (stream._duplexState | READ_QUEUED) & READ_PUSHED;
-			return this.buffered < this.highWaterMark;
-		}
-		shift() {
-			const data = this.queue.shift();
-			this.buffered -= this.byteLength(data);
-			if (this.buffered === 0) this.stream._duplexState &= READ_NOT_QUEUED;
-			return data;
-		}
-		unshift(data) {
-			const pending = [this.map !== null ? this.map(data) : data];
-			while (this.buffered > 0) pending.push(this.shift());
-			for (let i = 0; i < pending.length - 1; i++) {
-				const data = pending[i];
-				this.buffered += this.byteLength(data);
-				this.queue.push(data);
-			}
-			this.push(pending[pending.length - 1]);
-		}
-		read() {
-			const stream = this.stream;
-			if ((stream._duplexState & READ_STATUS) === READ_QUEUED) {
-				const data = this.shift();
-				if (this.pipeTo !== null && this.pipeTo.write(data) === false) stream._duplexState &= READ_PIPE_NOT_DRAINED;
-				if ((stream._duplexState & READ_EMIT_DATA) !== 0) stream.emit("data", data);
-				return data;
-			}
-			if (this.readAhead === false) {
-				stream._duplexState |= READ_READ_AHEAD;
-				this.updateNextTick();
-			}
-			return null;
-		}
-		drain() {
-			const stream = this.stream;
-			while ((stream._duplexState & READ_STATUS) === READ_QUEUED && (stream._duplexState & READ_FLOWING) !== 0) {
-				const data = this.shift();
-				if (this.pipeTo !== null && this.pipeTo.write(data) === false) stream._duplexState &= READ_PIPE_NOT_DRAINED;
-				if ((stream._duplexState & READ_EMIT_DATA) !== 0) stream.emit("data", data);
-			}
-		}
-		update() {
-			const stream = this.stream;
-			stream._duplexState |= READ_UPDATING;
-			do {
-				this.drain();
-				while (this.buffered < this.highWaterMark && (stream._duplexState & SHOULD_NOT_READ) === READ_READ_AHEAD) {
-					stream._duplexState |= READ_ACTIVE_AND_NEEDS_PUSH;
-					stream._read(this.afterRead);
-					this.drain();
-				}
-				if ((stream._duplexState & READ_READABLE_STATUS) === READ_EMIT_READABLE_AND_QUEUED) {
-					stream._duplexState |= READ_EMITTED_READABLE;
-					stream.emit("readable");
-				}
-				if ((stream._duplexState & READ_PRIMARY_AND_ACTIVE) === 0) this.updateNonPrimary();
-			} while (this.continueUpdate() === true);
-			stream._duplexState &= READ_NOT_UPDATING;
-		}
-		updateNonPrimary() {
-			const stream = this.stream;
-			if ((stream._duplexState & READ_ENDING_STATUS) === READ_ENDING) {
-				stream._duplexState = (stream._duplexState | READ_DONE) & READ_NOT_ENDING;
-				stream.emit("end");
-				if ((stream._duplexState & AUTO_DESTROY) === DONE) stream._duplexState |= DESTROYING;
-				if (this.pipeTo !== null) this.pipeTo.end();
-			}
-			if ((stream._duplexState & DESTROY_STATUS) === DESTROYING) {
-				if ((stream._duplexState & ACTIVE_OR_TICKING) === 0) {
-					stream._duplexState |= ACTIVE;
-					stream._destroy(afterDestroy.bind(this));
-				}
-				return;
-			}
-			if ((stream._duplexState & IS_OPENING) === OPENING) {
-				stream._duplexState = (stream._duplexState | ACTIVE) & NOT_OPENING;
-				stream._open(afterOpen.bind(this));
-			}
-		}
-		continueUpdate() {
-			if ((this.stream._duplexState & READ_NEXT_TICK) === 0) return false;
-			this.stream._duplexState &= READ_NOT_NEXT_TICK;
-			return true;
-		}
-		updateCallback() {
-			if ((this.stream._duplexState & READ_UPDATE_SYNC_STATUS) === READ_PRIMARY) this.update();
-			else this.updateNextTick();
-		}
-		updateNextTickIfOpen() {
-			if ((this.stream._duplexState & READ_NEXT_TICK_OR_OPENING) !== 0) return;
-			this.stream._duplexState |= READ_NEXT_TICK;
-			if ((this.stream._duplexState & READ_UPDATING) === 0) qmt(this.afterUpdateNextTick);
-		}
-		updateNextTick() {
-			if ((this.stream._duplexState & READ_NEXT_TICK) !== 0) return;
-			this.stream._duplexState |= READ_NEXT_TICK;
-			if ((this.stream._duplexState & READ_UPDATING) === 0) qmt(this.afterUpdateNextTick);
-		}
-	};
-	var TransformState = class {
-		constructor(stream) {
-			this.data = null;
-			this.afterTransform = afterTransform.bind(stream);
-			this.afterFinal = null;
-		}
-	};
-	var Pipeline = class {
-		constructor(src, dst, cb) {
-			this.from = src;
-			this.to = dst;
-			this.afterPipe = cb;
-			this.error = null;
-			this.pipeToFinished = false;
-		}
-		finished() {
-			this.pipeToFinished = true;
-		}
-		done(stream, err) {
-			if (err) this.error = err;
-			if (stream === this.to) {
-				this.to = null;
-				if (this.from !== null) {
-					if ((this.from._duplexState & READ_DONE) === 0 || !this.pipeToFinished) this.from.destroy(this.error || /* @__PURE__ */ new Error("Writable stream closed prematurely"));
+				case FILE:
+					pathConflicts.set(normalizedName, FILE);
+					await prepareDirectory(parentDir);
+					return path$1.join(await getRealDir(parentDir, `File "${name}" points outside the extraction directory.`), path$1.basename(outPath));
+				case SYMLINK: {
+					pathConflicts.set(normalizedName, SYMLINK);
+					if (!linkname) return;
+					validateBounds(path$1.resolve(parentDir, linkname), destDir.symbolic, `Symlink "${linkname}" points outside the extraction directory.`);
+					await prepareDirectory(parentDir);
+					const realParentDir = await fsp.realpath(parentDir);
+					validateBounds(realParentDir, destDir.real, "Symlink parent changed.");
+					validateBounds(path$1.resolve(realParentDir, linkname), destDir.real, `Symlink "${linkname}" points outside the extraction directory.`);
+					const realOutPath = path$1.join(realParentDir, path$1.basename(outPath));
+					try {
+						await fsp.symlink(linkname, realOutPath);
+					} catch (err) {
+						if (err.code !== "EEXIST") throw err;
+						await fsp.rm(realOutPath, { force: true });
+						if (await fsp.realpath(parentDir) !== realParentDir) throw new Error("Symlink parent changed.");
+						await fsp.symlink(linkname, realOutPath);
+					}
+					(symlinks ??= []).push([normalizedName, linkname]);
+					dirPromises.clear();
+					realDirCache.clear();
+					if (mtime) await fsp.lutimes(outPath, mtime, mtime).catch(() => {});
 					return;
 				}
-			}
-			if (stream === this.from) {
-				this.from = null;
-				if (this.to !== null) {
-					if ((stream._duplexState & READ_DONE) === 0) this.to.destroy(this.error || /* @__PURE__ */ new Error("Readable stream closed before ending"));
+				case LINK: {
+					pathConflicts.set(normalizedName, LINK);
+					if (!linkname) return;
+					if (path$1.isAbsolute(linkname)) throw new Error(`Hardlink "${linkname}" points outside the extraction directory.`);
+					const linkTarget = path$1.join(destDir.symbolic, linkname);
+					validateBounds(linkTarget, destDir.symbolic, `Hardlink "${linkname}" points outside the extraction directory.`);
+					await prepareDirectory(parentDir);
+					if (linkTarget !== outPath) deferredLinks.push({
+						linkTarget,
+						outPath
+					});
 					return;
 				}
+				default: return;
 			}
-			if (this.afterPipe !== null) this.afterPipe(this.error);
-			this.to = this.from = this.afterPipe = null;
-		}
-	};
-	function afterDrain() {
-		this.stream._duplexState |= READ_PIPE_DRAINED;
-		this.updateCallback();
-	}
-	function afterFinal(err) {
-		const stream = this.stream;
-		if (err) stream.destroy(err);
-		if ((stream._duplexState & DESTROY_STATUS) === 0) {
-			stream._duplexState |= WRITE_DONE;
-			stream.emit("finish");
-		}
-		if ((stream._duplexState & AUTO_DESTROY) === DONE) stream._duplexState |= DESTROYING;
-		stream._duplexState &= WRITE_NOT_FINISHING;
-		if ((stream._duplexState & WRITE_UPDATING) === 0) this.update();
-		else this.updateNextTick();
-	}
-	function afterDestroy(err) {
-		const stream = this.stream;
-		if (!err && !StreamError.isStreamDestroyed(this.error)) err = this.error;
-		if (err) stream.emit("error", err);
-		stream._duplexState |= DESTROYED;
-		stream.emit("close");
-		const rs = stream._readableState;
-		const ws = stream._writableState;
-		if (rs !== null && rs.pipeline !== null) rs.pipeline.done(stream, err);
-		if (ws !== null) {
-			while (ws.drains !== null && ws.drains.length > 0) ws.drains.shift().resolve(false);
-			if (ws.pipeline !== null) ws.pipeline.done(stream, err);
-		}
-	}
-	function afterWrite(err) {
-		const stream = this.stream;
-		if (err) stream.destroy(err);
-		stream._duplexState &= WRITE_NOT_ACTIVE;
-		if (this.drains !== null) tickDrains(this.drains);
-		if ((stream._duplexState & WRITE_DRAIN_STATUS) === WRITE_UNDRAINED) {
-			stream._duplexState &= WRITE_DRAINED;
-			if ((stream._duplexState & WRITE_EMIT_DRAIN) === WRITE_EMIT_DRAIN) stream.emit("drain");
-		}
-		this.updateCallback();
-	}
-	function afterRead(err) {
-		if (err) this.stream.destroy(err);
-		this.stream._duplexState &= READ_NOT_ACTIVE;
-		if (this.readAhead === false && (this.stream._duplexState & READ_RESUMED) === 0) this.stream._duplexState &= READ_NO_READ_AHEAD;
-		this.updateCallback();
-	}
-	function updateReadNT() {
-		if ((this.stream._duplexState & READ_UPDATING) === 0) {
-			this.stream._duplexState &= READ_NOT_NEXT_TICK;
-			this.update();
-		}
-	}
-	function updateWriteNT() {
-		if ((this.stream._duplexState & WRITE_UPDATING) === 0) {
-			this.stream._duplexState &= WRITE_NOT_NEXT_TICK;
-			this.update();
-		}
-	}
-	function tickDrains(drains) {
-		for (let i = 0; i < drains.length; i++) if (--drains[i].writes === 0) {
-			drains.shift().resolve(true);
-			i--;
-		}
-	}
-	function afterOpen(err) {
-		const stream = this.stream;
-		if (err) stream.destroy(err);
-		if ((stream._duplexState & DESTROYING) === 0) {
-			if ((stream._duplexState & READ_PRIMARY_STATUS) === 0) stream._duplexState |= READ_PRIMARY;
-			if ((stream._duplexState & WRITE_PRIMARY_STATUS) === 0) stream._duplexState |= WRITE_PRIMARY;
-			stream.emit("open");
-		}
-		stream._duplexState &= NOT_ACTIVE;
-		if (stream._writableState !== null) stream._writableState.updateCallback();
-		if (stream._readableState !== null) stream._readableState.updateCallback();
-	}
-	function afterTransform(err, data) {
-		if (data !== void 0 && data !== null) this.push(data);
-		this._writableState.afterWrite(err);
-	}
-	function newListener(name) {
-		if (this._readableState !== null) {
-			if (name === "data") {
-				this._duplexState |= 133376;
-				this._readableState.updateNextTick();
-			}
-			if (name === "readable") {
-				this._duplexState |= READ_EMIT_READABLE;
-				this._readableState.updateNextTick();
-			}
-		}
-		if (this._writableState !== null) {
-			if (name === "drain") {
-				this._duplexState |= WRITE_EMIT_DRAIN;
-				this._writableState.updateNextTick();
-			}
-		}
-	}
-	var Stream = class extends EventEmitter {
-		constructor(opts) {
-			super();
-			this._duplexState = 0;
-			this._readableState = null;
-			this._writableState = null;
-			if (opts) {
-				if (opts.open) this._open = opts.open;
-				if (opts.destroy) this._destroy = opts.destroy;
-				if (opts.predestroy) this._predestroy = opts.predestroy;
-				if (opts.signal) opts.signal.addEventListener("abort", abort.bind(this));
-			}
-			this.on("newListener", newListener);
-		}
-		_open(cb) {
-			cb(null);
-		}
-		_destroy(cb) {
-			cb(null);
-		}
-		_predestroy() {}
-		get readable() {
-			return this._readableState !== null ? true : void 0;
-		}
-		get writable() {
-			return this._writableState !== null ? true : void 0;
-		}
-		get destroyed() {
-			return (this._duplexState & DESTROYED) !== 0;
-		}
-		get destroying() {
-			return (this._duplexState & DESTROY_STATUS) !== 0;
-		}
-		destroy(err) {
-			if ((this._duplexState & DESTROY_STATUS) === 0) {
-				if (!err) err = StreamError.STREAM_DESTROYED();
-				this._duplexState = (this._duplexState | DESTROYING) & NON_PRIMARY;
-				if (this._readableState !== null) {
-					this._readableState.highWaterMark = 0;
-					this._readableState.error = err;
-				}
-				if (this._writableState !== null) {
-					this._writableState.highWaterMark = 0;
-					this._writableState.error = err;
-				}
-				this._duplexState |= PREDESTROYING;
-				this._predestroy();
-				this._duplexState &= NOT_PREDESTROYING;
-				if (this._readableState !== null) this._readableState.updateNextTick();
-				if (this._writableState !== null) this._writableState.updateNextTick();
-			}
-		}
-	};
-	var Readable = class Readable extends Stream {
-		constructor(opts) {
-			super(opts);
-			this._duplexState |= 8519681;
-			this._readableState = new ReadableState(this, opts);
-			if (opts) {
-				if (this._readableState.readAhead === false) this._duplexState &= READ_NO_READ_AHEAD;
-				if (opts.read) this._read = opts.read;
-				if (opts.eagerOpen) this._readableState.updateNextTick();
-				if (opts.encoding) this.setEncoding(opts.encoding);
-			}
-		}
-		static deferred(fn, opts) {
-			const out = new PassThrough(opts);
-			fn().then((src) => {
-				if (src === null) return out.end();
-				if (out.destroying) return;
-				pipeline(src, out, noop);
-			}).catch((err) => out.destroy(err));
-			return out;
-		}
-		setEncoding(encoding) {
-			const dec = new TextDecoder(encoding);
-			const map = this._readableState.map || echo;
-			this._readableState.map = mapOrSkip;
-			return this;
-			function mapOrSkip(data) {
-				const next = dec.push(data);
-				return next === "" && (data.byteLength !== 0 || dec.remaining > 0) ? null : map(next);
-			}
-		}
-		_read(cb) {
-			cb(null);
-		}
-		pipe(dest, cb) {
-			this._readableState.updateNextTick();
-			this._readableState.pipe(dest, cb);
-			return dest;
-		}
-		read() {
-			this._readableState.updateNextTick();
-			return this._readableState.read();
-		}
-		push(data) {
-			this._readableState.updateNextTickIfOpen();
-			return this._readableState.push(data);
-		}
-		unshift(data) {
-			this._readableState.updateNextTickIfOpen();
-			return this._readableState.unshift(data);
-		}
-		resume() {
-			this._duplexState |= READ_RESUMED_READ_AHEAD;
-			this._readableState.updateNextTick();
-			return this;
-		}
-		pause() {
-			this._duplexState &= this._readableState.readAhead === false ? READ_PAUSED_NO_READ_AHEAD : READ_PAUSED;
-			return this;
-		}
-		static _fromAsyncIterator(ite, opts) {
-			let destroy;
-			const rs = new Readable({
-				...opts,
-				read(cb) {
-					ite.next().then(push).then(cb.bind(null, null)).catch(cb);
-				},
-				predestroy() {
-					destroy = ite.return();
-				},
-				destroy(cb) {
-					if (!destroy) return cb(null);
-					destroy.then(cb.bind(null, null)).catch(cb);
-				}
-			});
-			return rs;
-			function push(data) {
-				if (data.done) rs.push(null);
-				else rs.push(data.value);
-			}
-		}
-		static from(data, opts) {
-			if (isReadStreamx(data)) return data;
-			if (data[asyncIterator]) return this._fromAsyncIterator(data[asyncIterator](), opts);
-			if (!Array.isArray(data)) data = data === void 0 ? [] : [data];
-			let i = 0;
-			return new Readable({
-				...opts,
-				read(cb) {
-					this.push(i === data.length ? null : data[i++]);
-					cb(null);
-				}
-			});
-		}
-		static isBackpressured(rs) {
-			return (rs._duplexState & READ_BACKPRESSURE_STATUS) !== 0 || rs._readableState.buffered >= rs._readableState.highWaterMark;
-		}
-		static isPaused(rs) {
-			return (rs._duplexState & READ_RESUMED) === 0;
-		}
-		[asyncIterator]() {
-			const stream = this;
-			let error = null;
-			let promiseResolve = null;
-			let promiseReject = null;
-			this.on("error", (err) => {
-				error = err;
-			});
-			this.on("readable", onreadable);
-			this.on("close", onclose);
-			return {
-				[asyncIterator]() {
-					return this;
-				},
-				next() {
-					return new Promise(function(resolve, reject) {
-						promiseResolve = resolve;
-						promiseReject = reject;
-						const data = stream.read();
-						if (data !== null) ondata(data);
-						else if ((stream._duplexState & DESTROYED) !== 0) ondata(null);
-					});
-				},
-				return() {
-					return destroy(null);
-				},
-				throw(err) {
-					return destroy(err);
-				}
+		},
+		async checkSymlinks() {
+			if (!symlinks) return;
+			const { symbolic: dest, real } = await destDirPromise;
+			const realPrefix = real + path$1.sep;
+			const root = path$1.parse(real).root;
+			const depth = linkParts(real.slice(root.length)).length;
+			const targetParts = (linkname, resolvedParts, message) => {
+				if (!path$1.isAbsolute(linkname)) return linkParts(linkname);
+				validateBounds(linkname, real, message);
+				resolvedParts.length = 0;
+				const parts = linkParts(linkname.slice(root.length));
+				parts.splice(0, depth);
+				return parts;
 			};
-			function onreadable() {
-				if (promiseResolve !== null) ondata(stream.read());
-			}
-			function onclose() {
-				if (promiseResolve !== null) ondata(null);
-			}
-			function ondata(data) {
-				if (promiseReject === null) return;
-				if (error) promiseReject(error);
-				else if (data === null && (stream._duplexState & READ_DONE) === 0) promiseReject(StreamError.STREAM_DESTROYED());
-				else promiseResolve({
-					value: data,
-					done: data === null
-				});
-				promiseReject = promiseResolve = null;
-			}
-			function destroy(err) {
-				stream.destroy(err);
-				return new Promise((resolve, reject) => {
-					if (stream._duplexState & DESTROYED) return resolve({
-						value: void 0,
-						done: true
-					});
-					stream.once("close", function() {
-						if (err) reject(err);
-						else resolve({
-							value: void 0,
-							done: true
-						});
-					});
-				});
-			}
-		}
-	};
-	var Writable = class extends Stream {
-		constructor(opts) {
-			super(opts);
-			this._duplexState |= 16385;
-			this._writableState = new WritableState(this, opts);
-			if (opts) {
-				if (opts.writev) this._writev = opts.writev;
-				if (opts.write) this._write = opts.write;
-				if (opts.final) this._final = opts.final;
-				if (opts.eagerOpen) this._writableState.updateNextTick();
-			}
-		}
-		cork() {
-			this._duplexState |= WRITE_CORKED;
-		}
-		uncork() {
-			this._duplexState &= WRITE_NOT_CORKED;
-			this._writableState.updateNextTick();
-		}
-		_writev(batch, cb) {
-			cb(null);
-		}
-		_write(data, cb) {
-			this._writableState.autoBatch(data, cb);
-		}
-		_final(cb) {
-			cb(null);
-		}
-		static isBackpressured(ws) {
-			return (ws._duplexState & WRITE_BACKPRESSURE_STATUS) !== 0;
-		}
-		static drained(ws) {
-			if (ws.destroyed) return Promise.resolve(false);
-			const state = ws._writableState;
-			const writes = (isWritev(ws) ? Math.min(1, state.queue.length) : state.queue.length) + (ws._duplexState & WRITE_WRITING ? 1 : 0);
-			if (writes === 0) return Promise.resolve(true);
-			if (state.drains === null) state.drains = [];
-			return new Promise((resolve) => {
-				state.drains.push({
-					writes,
-					resolve
-				});
-			});
-		}
-		write(data) {
-			this._writableState.updateNextTick();
-			return this._writableState.push(data);
-		}
-		end(data) {
-			this._writableState.updateNextTick();
-			this._writableState.end(data);
-			return this;
-		}
-	};
-	var Duplex = class extends Readable {
-		constructor(opts) {
-			super(opts);
-			this._duplexState = OPENING | this._duplexState & READ_READ_AHEAD;
-			this._writableState = new WritableState(this, opts);
-			if (opts) {
-				if (opts.writev) this._writev = opts.writev;
-				if (opts.write) this._write = opts.write;
-				if (opts.final) this._final = opts.final;
-			}
-		}
-		cork() {
-			this._duplexState |= WRITE_CORKED;
-		}
-		uncork() {
-			this._duplexState &= WRITE_NOT_CORKED;
-			this._writableState.updateNextTick();
-		}
-		_writev(batch, cb) {
-			cb(null);
-		}
-		_write(data, cb) {
-			this._writableState.autoBatch(data, cb);
-		}
-		_final(cb) {
-			cb(null);
-		}
-		write(data) {
-			this._writableState.updateNextTick();
-			return this._writableState.push(data);
-		}
-		end(data) {
-			this._writableState.updateNextTick();
-			this._writableState.end(data);
-			return this;
-		}
-	};
-	var Transform = class extends Duplex {
-		constructor(opts) {
-			super(opts);
-			this._transformState = new TransformState(this);
-			if (opts) {
-				if (opts.transform) this._transform = opts.transform;
-				if (opts.flush) this._flush = opts.flush;
-			}
-		}
-		_write(data, cb) {
-			if (this._readableState.buffered >= this._readableState.highWaterMark) this._transformState.data = data;
-			else this._transform(data, this._transformState.afterTransform);
-		}
-		_read(cb) {
-			if (this._transformState.data !== null) {
-				const data = this._transformState.data;
-				this._transformState.data = null;
-				cb(null);
-				this._transform(data, this._transformState.afterTransform);
-			} else cb(null);
-		}
-		destroy(err) {
-			super.destroy(err);
-			if (this._transformState.data !== null) {
-				this._transformState.data = null;
-				this._transformState.afterTransform();
-			}
-		}
-		_transform(data, cb) {
-			cb(null, data);
-		}
-		_flush(cb) {
-			cb(null);
-		}
-		_final(cb) {
-			this._transformState.afterFinal = cb;
-			this._flush(transformAfterFlush.bind(this));
-		}
-	};
-	var PassThrough = class extends Transform {};
-	function transformAfterFlush(err, data) {
-		const cb = this._transformState.afterFinal;
-		if (err) return cb(err);
-		if (data !== null && data !== void 0) this.push(data);
-		this.push(null);
-		cb(null);
-	}
-	function pipelinePromise(...streams) {
-		return new Promise((resolve, reject) => {
-			return pipeline(...streams, (err) => {
-				if (err) return reject(err);
-				resolve();
-			});
-		});
-	}
-	function pipeline(stream, ...streams) {
-		const all = Array.isArray(stream) ? [...stream, ...streams] : [stream, ...streams];
-		const done = all.length && typeof all[all.length - 1] === "function" ? all.pop() : null;
-		if (all.length < 2) throw new Error("Pipeline requires at least 2 streams");
-		let src = all[0];
-		let dest = null;
-		let error = null;
-		for (let i = 1; i < all.length; i++) {
-			dest = all[i];
-			if (isStreamx(src)) src.pipe(dest, onerror);
-			else {
-				errorHandle(src, true, i > 1, onerror);
-				src.pipe(dest);
-			}
-			src = dest;
-		}
-		if (done) {
-			let fin = false;
-			const autoDestroy = isStreamx(dest) || !!(dest._writableState && dest._writableState.autoDestroy);
-			dest.on("error", (err) => {
-				if (error === null) error = err;
-			});
-			dest.on("finish", () => {
-				fin = true;
-				if (!autoDestroy) done(error);
-			});
-			if (autoDestroy) dest.on("close", () => done(error || (fin ? null : StreamError.PREMATURE_CLOSE())));
-		}
-		return dest;
-		function errorHandle(s, rd, wr, onerror) {
-			s.on("error", onerror);
-			s.on("close", onclose);
-			function onclose() {
-				if (rd && s._readableState && !s._readableState.ended) return onerror(StreamError.PREMATURE_CLOSE());
-				if (wr && s._writableState && !s._writableState.ended) return onerror(StreamError.PREMATURE_CLOSE());
-			}
-		}
-		function onerror(err) {
-			if (!err || error) return;
-			error = err;
-			for (const s of all) s.destroy(err);
-		}
-	}
-	function echo(s) {
-		return s;
-	}
-	function isStream(stream) {
-		return !!stream._readableState || !!stream._writableState;
-	}
-	function isStreamx(stream) {
-		return typeof stream._duplexState === "number" && isStream(stream);
-	}
-	function isEnding(stream) {
-		return !!stream._readableState && stream._readableState.ending;
-	}
-	function isEnded(stream) {
-		return !!stream._readableState && stream._readableState.ended;
-	}
-	function isFinishing(stream) {
-		return !!stream._writableState && stream._writableState.ending;
-	}
-	function isFinished(stream) {
-		return !!stream._writableState && stream._writableState.ended;
-	}
-	function getStreamError(stream, opts = {}) {
-		const err = stream._readableState && stream._readableState.error || stream._writableState && stream._writableState.error;
-		return !opts.all && StreamError.isStreamDestroyed(err) ? null : err;
-	}
-	function isReadStreamx(stream) {
-		return isStreamx(stream) && stream.readable;
-	}
-	function isDisturbed(stream) {
-		return (stream._duplexState & OPENING) !== OPENING || (stream._duplexState & DESTROYING) === DESTROYING || (stream._duplexState & ACTIVE_OR_TICKING) !== 0;
-	}
-	function isTypedArray(data) {
-		return typeof data === "object" && data !== null && typeof data.byteLength === "number";
-	}
-	function defaultByteLength(data) {
-		return isTypedArray(data) ? data.byteLength : 1024;
-	}
-	function noop() {}
-	function abort() {
-		this.destroy(StreamError.ABORTED());
-	}
-	function isWritev(s) {
-		return s._writev !== Writable.prototype._writev && s._writev !== Duplex.prototype._writev;
-	}
-	module.exports = {
-		pipeline,
-		pipelinePromise,
-		isStream,
-		isStreamx,
-		isEnding,
-		isEnded,
-		isFinishing,
-		isFinished,
-		isDisturbed,
-		getStreamError,
-		Stream,
-		Writable,
-		Readable,
-		Duplex,
-		Transform,
-		PassThrough
-	};
-}));
-//#endregion
-//#region ../../node_modules/.pnpm/tar-stream@3.2.0/node_modules/tar-stream/headers.js
-var require_headers = /* @__PURE__ */ __commonJSMin(((exports) => {
-	const b4a = require_b4a();
-	const ZEROS = "0000000000000000000";
-	const SEVENS = "7777777777777777777";
-	const ZERO_OFFSET = "0".charCodeAt(0);
-	const USTAR_MAGIC = b4a.from([
-		117,
-		115,
-		116,
-		97,
-		114,
-		0
-	]);
-	const USTAR_VER = b4a.from([ZERO_OFFSET, ZERO_OFFSET]);
-	const GNU_MAGIC = b4a.from([
-		117,
-		115,
-		116,
-		97,
-		114,
-		32
-	]);
-	const GNU_VER = b4a.from([32, 0]);
-	const MASK = 4095;
-	const MAGIC_OFFSET = 257;
-	const VERSION_OFFSET = 263;
-	exports.decodeLongPath = function decodeLongPath(buf, encoding) {
-		return decodeStr(buf, 0, buf.length, encoding);
-	};
-	exports.encodePax = function encodePax(opts) {
-		let result = "";
-		if (opts.name) result += addLength(" path=" + opts.name + "\n");
-		if (opts.linkname) result += addLength(" linkpath=" + opts.linkname + "\n");
-		const pax = opts.pax;
-		if (pax) for (const key in pax) result += addLength(" " + key + "=" + pax[key] + "\n");
-		return b4a.from(result);
-	};
-	exports.decodePax = function decodePax(buf) {
-		const result = {};
-		while (buf.length) {
-			let i = 0;
-			while (i < buf.length && buf[i] !== 32) i++;
-			const len = parseInt(b4a.toString(buf.subarray(0, i)), 10);
-			if (!len) return result;
-			const b = b4a.toString(buf.subarray(i + 1, len - 1));
-			const keyIndex = b.indexOf("=");
-			if (keyIndex === -1) return result;
-			result[b.slice(0, keyIndex)] = b.slice(keyIndex + 1);
-			buf = buf.subarray(len);
-		}
-		return result;
-	};
-	exports.encode = function encode(opts) {
-		const buf = b4a.alloc(512);
-		let name = opts.name;
-		let prefix = "";
-		if (opts.typeflag === 5 && name[name.length - 1] !== "/") name += "/";
-		if (b4a.byteLength(name) !== name.length) return null;
-		while (b4a.byteLength(name) > 100) {
-			const i = name.indexOf("/");
-			if (i === -1) return null;
-			prefix += prefix ? "/" + name.slice(0, i) : name.slice(0, i);
-			name = name.slice(i + 1);
-		}
-		if (b4a.byteLength(name) > 100 || b4a.byteLength(prefix) > 155) return null;
-		if (opts.linkname && b4a.byteLength(opts.linkname) > 100) return null;
-		b4a.write(buf, name);
-		b4a.write(buf, encodeOct(opts.mode & MASK, 6), 100);
-		b4a.write(buf, encodeOct(opts.uid, 6), 108);
-		b4a.write(buf, encodeOct(opts.gid, 6), 116);
-		encodeSize(opts.size, buf, 124);
-		b4a.write(buf, encodeOct(opts.mtime.getTime() / 1e3 | 0, 11), 136);
-		buf[156] = ZERO_OFFSET + toTypeflag(opts.type);
-		if (opts.linkname) b4a.write(buf, opts.linkname, 157);
-		b4a.copy(USTAR_MAGIC, buf, MAGIC_OFFSET);
-		b4a.copy(USTAR_VER, buf, VERSION_OFFSET);
-		if (opts.uname) b4a.write(buf, opts.uname, 265);
-		if (opts.gname) b4a.write(buf, opts.gname, 297);
-		b4a.write(buf, encodeOct(opts.devmajor || 0, 6), 329);
-		b4a.write(buf, encodeOct(opts.devminor || 0, 6), 337);
-		if (prefix) b4a.write(buf, prefix, 345);
-		b4a.write(buf, encodeOct(cksum(buf), 6), 148);
-		return buf;
-	};
-	exports.decode = function decode(buf, filenameEncoding, allowUnknownFormat) {
-		let typeflag = buf[156] === 0 ? 0 : buf[156] - ZERO_OFFSET;
-		let name = decodeStr(buf, 0, 100, filenameEncoding);
-		const mode = decodeOct(buf, 100, 8);
-		const uid = decodeOct(buf, 108, 8);
-		const gid = decodeOct(buf, 116, 8);
-		const size = decodeOct(buf, 124, 12);
-		const mtime = decodeOct(buf, 136, 12);
-		const type = toType(typeflag);
-		const linkname = buf[157] === 0 ? null : decodeStr(buf, 157, 100, filenameEncoding);
-		const uname = decodeStr(buf, 265, 32);
-		const gname = decodeStr(buf, 297, 32);
-		const devmajor = decodeOct(buf, 329, 8);
-		const devminor = decodeOct(buf, 337, 8);
-		const c = cksum(buf);
-		if (c === 256) return null;
-		if (c !== decodeOct(buf, 148, 8)) throw new Error("Invalid tar header. Maybe the tar is corrupted or it needs to be gunzipped?");
-		if (isUSTAR(buf)) {
-			if (buf[345]) name = decodeStr(buf, 345, 155, filenameEncoding) + "/" + name;
-		} else if (isGNU(buf)) {} else if (!allowUnknownFormat) throw new Error("Invalid tar header: unknown format.");
-		if (typeflag === 0 && name && name[name.length - 1] === "/") typeflag = 5;
-		return {
-			name,
-			mode,
-			uid,
-			gid,
-			size,
-			byteOffset: 0,
-			mtime: /* @__PURE__ */ new Date(1e3 * mtime),
-			type,
-			linkname,
-			uname,
-			gname,
-			devmajor,
-			devminor,
-			pax: null
-		};
-	};
-	function isUSTAR(buf) {
-		return b4a.equals(USTAR_MAGIC, buf.subarray(MAGIC_OFFSET, 263));
-	}
-	function isGNU(buf) {
-		return b4a.equals(GNU_MAGIC, buf.subarray(MAGIC_OFFSET, 263)) && b4a.equals(GNU_VER, buf.subarray(VERSION_OFFSET, 265));
-	}
-	function clamp(index, len, defaultValue) {
-		if (typeof index !== "number") return defaultValue;
-		index = ~~index;
-		if (index >= len) return len;
-		if (index >= 0) return index;
-		index += len;
-		if (index >= 0) return index;
-		return 0;
-	}
-	function toType(flag) {
-		switch (flag) {
-			case 0: return "file";
-			case 1: return "link";
-			case 2: return "symlink";
-			case 3: return "character-device";
-			case 4: return "block-device";
-			case 5: return "directory";
-			case 6: return "fifo";
-			case 7: return "contiguous-file";
-			case 72: return "pax-header";
-			case 55: return "pax-global-header";
-			case 27: return "gnu-long-link-path";
-			case 28:
-			case 30: return "gnu-long-path";
-		}
-		return null;
-	}
-	function toTypeflag(flag) {
-		switch (flag) {
-			case "file": return 0;
-			case "link": return 1;
-			case "symlink": return 2;
-			case "character-device": return 3;
-			case "block-device": return 4;
-			case "directory": return 5;
-			case "fifo": return 6;
-			case "contiguous-file": return 7;
-			case "pax-header": return 72;
-		}
-		return 0;
-	}
-	function indexOf(block, num, offset, end) {
-		for (; offset < end; offset++) if (block[offset] === num) return offset;
-		return end;
-	}
-	function cksum(block) {
-		let sum = 256;
-		for (let i = 0; i < 148; i++) sum += block[i];
-		for (let j = 156; j < 512; j++) sum += block[j];
-		return sum;
-	}
-	function encodeOct(val, n) {
-		val = val.toString(8);
-		if (val.length > n) return SEVENS.slice(0, n) + " ";
-		return ZEROS.slice(0, n - val.length) + val + " ";
-	}
-	function encodeSizeBin(num, buf, off) {
-		buf[off] = 128;
-		for (let i = 11; i > 0; i--) {
-			buf[off + i] = num & 255;
-			num = Math.floor(num / 256);
-		}
-	}
-	function encodeSize(num, buf, off) {
-		if (num.toString(8).length > 11) encodeSizeBin(num, buf, off);
-		else b4a.write(buf, encodeOct(num, 11), off);
-	}
-	function parse256(buf) {
-		let positive;
-		if (buf[0] === 128) positive = true;
-		else if (buf[0] === 255) positive = false;
-		else return null;
-		const tuple = [];
-		let i;
-		for (i = buf.length - 1; i > 0; i--) {
-			const byte = buf[i];
-			if (positive) tuple.push(byte);
-			else tuple.push(255 - byte);
-		}
-		let sum = 0;
-		const l = tuple.length;
-		for (i = 0; i < l; i++) sum += tuple[i] * Math.pow(256, i);
-		return positive ? sum : -1 * sum;
-	}
-	function decodeOct(val, offset, length) {
-		val = val.subarray(offset, offset + length);
-		offset = 0;
-		if (val[offset] & 128) return parse256(val);
-		else {
-			while (offset < val.length && val[offset] === 32) offset++;
-			const end = clamp(indexOf(val, 32, offset, val.length), val.length, val.length);
-			while (offset < end && val[offset] === 0) offset++;
-			if (end === offset) return 0;
-			return parseInt(b4a.toString(val.subarray(offset, end)), 8);
-		}
-	}
-	function decodeStr(val, offset, length, encoding) {
-		return b4a.toString(val.subarray(offset, indexOf(val, 0, offset, offset + length)), encoding);
-	}
-	function addLength(str) {
-		const len = b4a.byteLength(str);
-		let digits = Math.floor(Math.log(len) / Math.log(10)) + 1;
-		if (len + digits >= Math.pow(10, digits)) digits++;
-		return len + digits + str;
-	}
-}));
-//#endregion
-//#region ../../node_modules/.pnpm/tar-stream@3.2.0/node_modules/tar-stream/extract.js
-var require_extract = /* @__PURE__ */ __commonJSMin(((exports, module) => {
-	const { Writable, Readable, getStreamError } = require_streamx();
-	const FIFO = require_fast_fifo();
-	const b4a = require_b4a();
-	const headers = require_headers();
-	const EMPTY = b4a.alloc(0);
-	const MAX_HEADER_SIZE = 4 * 1024 * 1024;
-	var BufferList = class {
-		constructor() {
-			this.buffered = 0;
-			this.shifted = 0;
-			this.queue = new FIFO();
-			this._offset = 0;
-		}
-		push(buffer) {
-			this.buffered += buffer.byteLength;
-			this.queue.push(buffer);
-		}
-		shiftFirst(size) {
-			return this.buffered === 0 ? null : this._next(size);
-		}
-		shift(size) {
-			if (size > this.buffered) return null;
-			if (size === 0) return EMPTY;
-			let chunk = this._next(size);
-			if (size === chunk.byteLength) return chunk;
-			const chunks = [chunk];
-			while ((size -= chunk.byteLength) > 0) {
-				chunk = this._next(size);
-				chunks.push(chunk);
-			}
-			return b4a.concat(chunks);
-		}
-		_next(size) {
-			const buf = this.queue.peek();
-			const rem = buf.byteLength - this._offset;
-			if (size >= rem) {
-				const sub = this._offset ? buf.subarray(this._offset, buf.byteLength) : buf;
-				this.queue.shift();
-				this._offset = 0;
-				this.buffered -= rem;
-				this.shifted += rem;
-				return sub;
-			}
-			this.buffered -= size;
-			this.shifted += size;
-			return buf.subarray(this._offset, this._offset += size);
-		}
-	};
-	var Source = class extends Readable {
-		constructor(self, header, offset) {
-			super();
-			this.header = header;
-			this.offset = offset;
-			this._parent = self;
-		}
-		_read(cb) {
-			if (this.header.size === 0) this.push(null);
-			if (this._parent._stream === this) this._parent._update();
-			cb(null);
-		}
-		_predestroy() {
-			this._parent.destroy(getStreamError(this));
-		}
-		_detach() {
-			if (this._parent._stream === this) {
-				this._parent._stream = null;
-				this._parent._missing = overflow(this.header.size);
-				this._parent._update();
-			}
-		}
-		_destroy(cb) {
-			this._detach();
-			cb(null);
-		}
-	};
-	var Extract = class extends Writable {
-		constructor(opts) {
-			super(opts);
-			if (!opts) opts = {};
-			this._buffer = new BufferList();
-			this._offset = 0;
-			this._header = null;
-			this._stream = null;
-			this._missing = 0;
-			this._longHeader = false;
-			this._callback = noop;
-			this._locked = false;
-			this._finished = false;
-			this._pax = null;
-			this._paxGlobal = null;
-			this._gnuLongPath = null;
-			this._gnuLongLinkPath = null;
-			this._filenameEncoding = opts.filenameEncoding || "utf-8";
-			this._allowUnknownFormat = !!opts.allowUnknownFormat;
-			this._unlockBound = this._unlock.bind(this);
-		}
-		_unlock(err) {
-			this._locked = false;
-			if (err) {
-				this.destroy(err);
-				this._continueWrite(err);
-				return;
-			}
-			this._update();
-		}
-		_consumeHeader() {
-			if (this._locked) return false;
-			this._offset = this._buffer.shifted;
-			try {
-				this._header = headers.decode(this._buffer.shift(512), this._filenameEncoding, this._allowUnknownFormat);
-			} catch (err) {
-				this._continueWrite(err);
-				return false;
-			}
-			if (!this._header) return true;
-			this._header.byteOffset = this._buffer.shifted;
-			switch (this._header.type) {
-				case "gnu-long-path":
-				case "gnu-long-link-path":
-				case "pax-global-header":
-				case "pax-header":
-					this._longHeader = true;
-					this._missing = this._header.size;
-					if (this._missing > MAX_HEADER_SIZE) {
-						this._continueWrite(/* @__PURE__ */ new Error("Header exceeds max size"));
-						return false;
-					}
-					return true;
-			}
-			this._locked = true;
-			this._applyLongHeaders();
-			if (!(this._header.size >= 0)) {
-				this._continueWrite(/* @__PURE__ */ new Error("Invalid header"));
-				return false;
-			}
-			if (this._header.size === 0 || this._header.type === "directory") {
-				this.emit("entry", this._header, this._createStream(), this._unlockBound);
-				return true;
-			}
-			this._stream = this._createStream();
-			this._missing = this._header.size;
-			this.emit("entry", this._header, this._stream, this._unlockBound);
-			return true;
-		}
-		_applyLongHeaders() {
-			if (this._gnuLongPath) {
-				this._header.name = this._gnuLongPath;
-				this._gnuLongPath = null;
-			}
-			if (this._gnuLongLinkPath) {
-				this._header.linkname = this._gnuLongLinkPath;
-				this._gnuLongLinkPath = null;
-			}
-			if (this._pax) {
-				if (this._pax.path) this._header.name = this._pax.path;
-				if (this._pax.linkpath) this._header.linkname = this._pax.linkpath;
-				if (this._pax.size) this._header.size = parseInt(this._pax.size, 10);
-				this._header.pax = this._pax;
-				this._pax = null;
-			}
-		}
-		_decodeLongHeader(buf) {
-			switch (this._header.type) {
-				case "gnu-long-path":
-					this._gnuLongPath = headers.decodeLongPath(buf, this._filenameEncoding);
-					break;
-				case "gnu-long-link-path":
-					this._gnuLongLinkPath = headers.decodeLongPath(buf, this._filenameEncoding);
-					break;
-				case "pax-global-header":
-					this._paxGlobal = headers.decodePax(buf);
-					break;
-				case "pax-header":
-					this._pax = this._paxGlobal === null ? headers.decodePax(buf) : Object.assign({}, this._paxGlobal, headers.decodePax(buf));
-					break;
-			}
-		}
-		_consumeLongHeader() {
-			this._longHeader = false;
-			this._missing = overflow(this._header.size);
-			const buf = this._buffer.shift(this._header.size);
-			try {
-				this._decodeLongHeader(buf);
-			} catch (err) {
-				this._continueWrite(err);
-				return false;
-			}
-			return true;
-		}
-		_consumeStream() {
-			const buf = this._buffer.shiftFirst(this._missing);
-			if (buf === null) return false;
-			this._missing -= buf.byteLength;
-			const drained = this._stream.push(buf);
-			if (this._missing === 0) {
-				this._stream.push(null);
-				if (drained) this._stream._detach();
-				return drained && this._locked === false;
-			}
-			return drained;
-		}
-		_createStream() {
-			return new Source(this, this._header, this._offset);
-		}
-		_update() {
-			while (this._buffer.buffered > 0 && !this.destroying) {
-				if (this._missing > 0) {
-					if (this._stream !== null) {
-						if (this._consumeStream() === false) return;
-						continue;
+			const getSymlinkError = async ([name, storedLinkname]) => {
+				const outPath = path$1.join(dest, name);
+				try {
+					try {
+						const resolved = await fsp.realpath(outPath);
+						if (resolved !== real && !resolved.startsWith(realPrefix)) throw new Error(`Symlink "${storedLinkname}" points outside the extraction directory.`);
+						return;
+					} catch (err) {
+						if (err.code !== ENOENT) throw err;
 					}
-					if (this._longHeader === true) {
-						if (this._missing > this._buffer.buffered) break;
-						if (this._consumeLongHeader() === false) return false;
-						continue;
+					if (!(await fsp.lstat(outPath)).isSymbolicLink()) return;
+					const linkname = await fsp.readlink(outPath);
+					const message = `Symlink "${linkname}" points outside the extraction directory.`;
+					const realParent = await fsp.realpath(path$1.dirname(outPath));
+					validateBounds(realParent, real, message);
+					const resolvedParts = linkParts(path$1.relative(real, realParent));
+					const pendingParts = targetParts(linkname, resolvedParts, message);
+					let followedSymlinks = 0;
+					for (let i = 0; i < pendingParts.length; i++) {
+						const part = pendingParts[i];
+						if (part === "..") {
+							if (!resolvedParts.length) throw new Error(message);
+							resolvedParts.pop();
+							continue;
+						}
+						resolvedParts.push(part);
+						const nextPath = path$1.join(real, ...resolvedParts);
+						let nextStat;
+						try {
+							nextStat = await fsp.lstat(nextPath);
+						} catch (err) {
+							if (err.code === ENOENT) continue;
+							throw err;
+						}
+						if (!nextStat.isSymbolicLink()) continue;
+						if (++followedSymlinks > MAX_SYMLINKS) throw new Error(message);
+						const nextLink = await fsp.readlink(nextPath);
+						resolvedParts.pop();
+						pendingParts.splice(i + 1, 0, ...targetParts(nextLink, resolvedParts, message));
 					}
-					const ignore = this._buffer.shiftFirst(this._missing);
-					if (ignore !== null) this._missing -= ignore.byteLength;
-					continue;
-				}
-				if (this._buffer.buffered < 512) break;
-				if (this._stream !== null || this._consumeHeader() === false) return;
-			}
-			this._continueWrite(null);
-		}
-		_continueWrite(err) {
-			const cb = this._callback;
-			this._callback = noop;
-			cb(err);
-		}
-		_write(data, cb) {
-			this._callback = cb;
-			this._buffer.push(data);
-			this._update();
-		}
-		_final(cb) {
-			this._finished = this._missing === 0 && this._buffer.buffered === 0;
-			cb(this._finished ? null : /* @__PURE__ */ new Error("Unexpected end of data"));
-		}
-		_predestroy() {
-			this._continueWrite(null);
-		}
-		_destroy(cb) {
-			if (this._stream) this._stream.destroy(getStreamError(this));
-			cb(null);
-		}
-		[Symbol.asyncIterator]() {
-			let error = null;
-			let promiseResolve = null;
-			let promiseReject = null;
-			let entryStream = null;
-			let entryCallback = null;
-			const extract = this;
-			this.on("entry", onentry);
-			this.on("error", (err) => {
-				error = err;
-			});
-			this.on("close", onclose);
-			return {
-				[Symbol.asyncIterator]() {
-					return this;
-				},
-				next() {
-					return new Promise(onnext);
-				},
-				return() {
-					return destroy(null);
-				},
-				throw(err) {
-					return destroy(err);
+				} catch (err) {
+					if (err.code !== ENOENT) return err;
 				}
 			};
-			function consumeCallback(err) {
-				if (!entryCallback) return;
-				const cb = entryCallback;
-				entryCallback = null;
-				cb(err);
-			}
-			function onnext(resolve, reject) {
-				if (error) return reject(error);
-				if (entryStream) {
-					resolve({
-						value: entryStream,
-						done: false
-					});
-					entryStream = null;
-					return;
+			for (let start = 0; start < symlinks.length; start += concurrency) {
+				const batch = symlinks.slice(start, start + concurrency);
+				const errors = await Promise.all(batch.map((symlink) => opQueue.add(() => getSymlinkError(symlink))));
+				for (const [i, error] of errors.entries()) {
+					if (error === void 0) continue;
+					await fsp.rm(path$1.join(dest, batch[i][0]), { force: true });
+					throw error;
 				}
-				promiseResolve = resolve;
-				promiseReject = reject;
-				consumeCallback(null);
-				if (extract._finished && promiseResolve) {
-					promiseResolve({
-						value: void 0,
-						done: true
-					});
-					promiseResolve = promiseReject = null;
-				}
-			}
-			function onentry(header, stream, callback) {
-				entryCallback = callback;
-				stream.on("error", noop);
-				if (promiseResolve) {
-					promiseResolve({
-						value: stream,
-						done: false
-					});
-					promiseResolve = promiseReject = null;
-				} else entryStream = stream;
-			}
-			function onclose() {
-				consumeCallback(error);
-				if (!promiseResolve) return;
-				if (error) promiseReject(error);
-				else promiseResolve({
-					value: void 0,
-					done: true
-				});
-				promiseResolve = promiseReject = null;
 			}
-			function destroy(err) {
-				extract.destroy(err);
-				consumeCallback(err);
-				return new Promise((resolve, reject) => {
-					if (extract.destroyed) return resolve({
-						value: void 0,
-						done: true
-					});
-					extract.once("close", function() {
-						if (err) reject(err);
-						else resolve({
-							value: void 0,
-							done: true
-						});
-					});
-				});
-			}
-		}
-	};
-	module.exports = function extract(opts) {
-		return new Extract(opts);
-	};
-	function noop() {}
-	function overflow(size) {
-		size &= 511;
-		return size && 512 - size;
-	}
-}));
-//#endregion
-//#region ../../node_modules/.pnpm/tar-stream@3.2.0/node_modules/tar-stream/constants.js
-var require_constants = /* @__PURE__ */ __commonJSMin(((exports, module) => {
-	const constants = {
-		S_IFMT: 61440,
-		S_IFDIR: 16384,
-		S_IFCHR: 8192,
-		S_IFBLK: 24576,
-		S_IFIFO: 4096,
-		S_IFLNK: 40960
-	};
-	try {
-		module.exports = __require("fs").constants || constants;
-	} catch {
-		module.exports = constants;
-	}
-}));
-//#endregion
-//#region ../../node_modules/.pnpm/tar-stream@3.2.0/node_modules/tar-stream/pack.js
-var require_pack = /* @__PURE__ */ __commonJSMin(((exports, module) => {
-	const { Readable, Writable, getStreamError } = require_streamx();
-	const b4a = require_b4a();
-	const constants = require_constants();
-	const headers = require_headers();
-	const DMODE = 493;
-	const FMODE = 420;
-	const END_OF_TAR = b4a.alloc(1024);
-	var Sink = class extends Writable {
-		constructor(pack, header, callback) {
-			super({
-				mapWritable,
-				eagerOpen: true
-			});
-			this.written = 0;
-			this.header = header;
-			this._callback = callback;
-			this._linkname = null;
-			this._isLinkname = header.type === "symlink" && !header.linkname;
-			this._isVoid = header.type !== "file" && header.type !== "contiguous-file";
-			this._finished = false;
-			this._pack = pack;
-			this._openCallback = null;
-			if (this._pack._stream === null) this._pack._stream = this;
-			else this._pack._pending.push(this);
-		}
-		_open(cb) {
-			this._openCallback = cb;
-			if (this._pack._stream === this) this._continueOpen();
-		}
-		_continuePack(err) {
-			if (this._callback === null) return;
-			const callback = this._callback;
-			this._callback = null;
-			callback(err);
-		}
-		_continueOpen() {
-			if (this._pack._stream === null) this._pack._stream = this;
-			const cb = this._openCallback;
-			this._openCallback = null;
-			if (cb === null) return;
-			if (this._pack.destroying) return cb(/* @__PURE__ */ new Error("pack stream destroyed"));
-			if (this._pack._finalized) return cb(/* @__PURE__ */ new Error("pack stream is already finalized"));
-			this._pack._stream = this;
-			if (!this._isLinkname) this._pack._encode(this.header);
-			if (this._isVoid) {
-				this._finish();
-				this._continuePack(null);
-			}
-			cb(null);
-		}
-		_write(data, cb) {
-			if (this._isLinkname) {
-				this._linkname = this._linkname ? b4a.concat([this._linkname, data]) : data;
-				return cb(null);
-			}
-			if (this._isVoid) {
-				if (data.byteLength > 0) return cb(/* @__PURE__ */ new Error("No body allowed for this entry"));
-				return cb();
-			}
-			this.written += data.byteLength;
-			if (this._pack.push(data)) return cb();
-			this._pack._drain = cb;
-		}
-		_finish() {
-			if (this._finished) return;
-			this._finished = true;
-			if (this._isLinkname) {
-				this.header.linkname = this._linkname ? b4a.toString(this._linkname, "utf-8") : "";
-				this._pack._encode(this.header);
-			}
-			overflow(this._pack, this.header.size);
-			this._pack._done(this);
-		}
-		_final(cb) {
-			if (this.written !== this.header.size) return cb(/* @__PURE__ */ new Error("Size mismatch"));
-			this._finish();
-			cb(null);
-		}
-		_getError() {
-			return getStreamError(this) || /* @__PURE__ */ new Error("tar entry destroyed");
-		}
-		_predestroy() {
-			this._pack.destroy(this._getError());
-		}
-		_destroy(cb) {
-			this._pack._done(this);
-			this._continuePack(this._finished ? null : this._getError());
-			cb();
-		}
-	};
-	var Pack = class extends Readable {
-		constructor(opts) {
-			super(opts);
-			this._drain = noop;
-			this._finalized = false;
-			this._finalizing = false;
-			this._pending = [];
-			this._stream = null;
-		}
-		entry(header, buffer, callback) {
-			if (this._finalized || this.destroying) throw new Error("already finalized or destroyed");
-			if (typeof buffer === "function") {
-				callback = buffer;
-				buffer = null;
-			}
-			if (!callback) callback = noop;
-			if (!header.size || header.type === "symlink") header.size = 0;
-			if (!header.type) header.type = modeToType(header.mode);
-			if (!header.mode) header.mode = header.type === "directory" ? DMODE : FMODE;
-			if (!header.uid) header.uid = 0;
-			if (!header.gid) header.gid = 0;
-			if (!header.mtime) header.mtime = /* @__PURE__ */ new Date();
-			if (typeof buffer === "string") buffer = b4a.from(buffer);
-			const sink = new Sink(this, header, callback);
-			if (b4a.isBuffer(buffer)) {
-				header.size = buffer.byteLength;
-				sink.write(buffer);
-				sink.end();
-				return sink;
-			}
-			if (sink._isVoid) return sink;
-			return sink;
-		}
-		finalize() {
-			if (this._stream || this._pending.length > 0) {
-				this._finalizing = true;
-				return;
-			}
-			if (this._finalized) return;
-			this._finalized = true;
-			this.push(END_OF_TAR);
-			this.push(null);
-		}
-		_done(stream) {
-			if (stream !== this._stream) return;
-			this._stream = null;
-			if (this._finalizing) this.finalize();
-			if (this._pending.length) this._pending.shift()._continueOpen();
-		}
-		_encode(header) {
-			if (!header.pax) {
-				const buf = headers.encode(header);
-				if (buf) {
-					this.push(buf);
-					return;
+		},
+		async applyLinks() {
+			const destRoot = (await destDirPromise).real;
+			for (const { linkTarget, outPath } of deferredLinks) try {
+				const realTargetDir = await fsp.realpath(path$1.dirname(linkTarget));
+				validateBounds(realTargetDir, destRoot, `Hardlink "${linkTarget}" points outside the extraction directory.`);
+				const realTarget = path$1.join(realTargetDir, path$1.basename(linkTarget));
+				const [targetResult, outDirResult] = await Promise.allSettled([opQueue.add(() => fsp.lstat(realTarget)), opQueue.add(() => fsp.realpath(path$1.dirname(outPath)))]);
+				if (targetResult.status === "rejected") throw targetResult.reason;
+				const targetStat = targetResult.value;
+				if (targetStat.isSymbolicLink()) throw new Error(`Hardlink "${linkTarget}" is a symlink.`);
+				if (outDirResult.status === "rejected") throw outDirResult.reason;
+				const realOutDir = outDirResult.value;
+				validateBounds(realOutDir, destRoot, `Hardlink "${outPath}" points outside the extraction directory.`);
+				const realOutPath = path$1.join(realOutDir, path$1.basename(outPath));
+				try {
+					await fsp.link(realTarget, realOutPath);
+				} catch (err) {
+					const code = err.code;
+					if (code !== "EEXIST" && code !== ENOENT) throw err;
+					try {
+						const outStat = await fsp.lstat(realOutPath);
+						if (outStat.dev === targetStat.dev && outStat.ino === targetStat.ino) continue;
+						await fsp.rm(realOutPath, { force: true });
+					} catch (err) {
+						if (err.code !== ENOENT) throw err;
+					}
+					await fsp.link(realTarget, realOutPath);
 				}
+				const linkStat = await fsp.lstat(realOutPath);
+				if (linkStat.dev !== targetStat.dev || linkStat.ino !== targetStat.ino) {
+					await fsp.rm(realOutPath, { force: true });
+					throw new Error(`Hardlink target "${linkTarget}" changed during creation for link at "${outPath}".`);
+				}
+			} catch (err) {
+				if (err.code === ENOENT) throw new Error(`Hardlink target "${linkTarget}" does not exist for link at "${outPath}".`);
+				throw err;
 			}
-			this._encodePax(header);
-		}
-		_encodePax(header) {
-			const paxHeader = headers.encodePax({
-				name: header.name,
-				linkname: header.linkname,
-				pax: header.pax
-			});
-			const newHeader = {
-				name: "PaxHeader",
-				mode: header.mode,
-				uid: header.uid,
-				gid: header.gid,
-				size: paxHeader.byteLength,
-				mtime: header.mtime,
-				type: "pax-header",
-				linkname: header.linkname && "PaxHeader",
-				uname: header.uname,
-				gname: header.gname,
-				devmajor: header.devmajor,
-				devminor: header.devminor
-			};
-			this.push(headers.encode(newHeader));
-			this.push(paxHeader);
-			overflow(this, paxHeader.byteLength);
-			newHeader.size = header.size;
-			newHeader.type = header.type;
-			this.push(headers.encode(newHeader));
-		}
-		_doDrain() {
-			const drain = this._drain;
-			this._drain = noop;
-			drain();
-		}
-		_predestroy() {
-			const err = getStreamError(this);
-			if (this._stream) this._stream.destroy(err);
-			while (this._pending.length) {
-				const stream = this._pending.shift();
-				stream.destroy(err);
-				stream._continueOpen();
-			}
-			this._doDrain();
-		}
-		_read(cb) {
-			this._doDrain();
-			cb();
-		}
-	};
-	module.exports = function pack(opts) {
-		return new Pack(opts);
-	};
-	function modeToType(mode) {
-		switch (mode & constants.S_IFMT) {
-			case constants.S_IFBLK: return "block-device";
-			case constants.S_IFCHR: return "character-device";
-			case constants.S_IFDIR: return "directory";
-			case constants.S_IFIFO: return "fifo";
-			case constants.S_IFLNK: return "symlink";
-		}
-		return "file";
-	}
-	function noop() {}
-	function overflow(self, size) {
-		size &= 511;
-		if (size) self.push(END_OF_TAR.subarray(0, 512 - size));
-	}
-	function mapWritable(buf) {
-		return b4a.isBuffer(buf) ? buf : b4a.from(buf);
-	}
-}));
-//#endregion
-//#region ../../node_modules/.pnpm/tar-stream@3.2.0/node_modules/tar-stream/index.js
-var require_tar_stream = /* @__PURE__ */ __commonJSMin(((exports) => {
-	exports.extract = require_extract();
-	exports.pack = require_pack();
-}));
-//#endregion
-//#region ../../node_modules/.pnpm/wrappy@1.0.2/node_modules/wrappy/wrappy.js
-var require_wrappy = /* @__PURE__ */ __commonJSMin(((exports, module) => {
-	module.exports = wrappy;
-	function wrappy(fn, cb) {
-		if (fn && cb) return wrappy(fn)(cb);
-		if (typeof fn !== "function") throw new TypeError("need wrapper function");
-		Object.keys(fn).forEach(function(k) {
-			wrapper[k] = fn[k];
-		});
-		return wrapper;
-		function wrapper() {
-			var args = new Array(arguments.length);
-			for (var i = 0; i < args.length; i++) args[i] = arguments[i];
-			var ret = fn.apply(this, args);
-			var cb = args[args.length - 1];
-			if (typeof ret === "function" && ret !== cb) Object.keys(cb).forEach(function(k) {
-				ret[k] = cb[k];
-			});
-			return ret;
 		}
-	}
-}));
-//#endregion
-//#region ../../node_modules/.pnpm/once@1.4.0/node_modules/once/once.js
-var require_once = /* @__PURE__ */ __commonJSMin(((exports, module) => {
-	var wrappy = require_wrappy();
-	module.exports = wrappy(once);
-	module.exports.strict = wrappy(onceStrict);
-	once.proto = once(function() {
-		Object.defineProperty(Function.prototype, "once", {
-			value: function() {
-				return once(this);
-			},
-			configurable: true
-		});
-		Object.defineProperty(Function.prototype, "onceStrict", {
-			value: function() {
-				return onceStrict(this);
-			},
-			configurable: true
-		});
-	});
-	function once(fn) {
-		var f = function() {
-			if (f.called) return f.value;
-			f.called = true;
-			return f.value = fn.apply(this, arguments);
-		};
-		f.called = false;
-		return f;
-	}
-	function onceStrict(fn) {
-		var f = function() {
-			if (f.called) throw new Error(f.onceError);
-			f.called = true;
-			return f.value = fn.apply(this, arguments);
-		};
-		f.onceError = (fn.name || "Function wrapped with `once`") + " shouldn't be called more than once";
-		f.called = false;
-		return f;
-	}
-}));
-//#endregion
-//#region ../../node_modules/.pnpm/end-of-stream@1.4.5/node_modules/end-of-stream/index.js
-var require_end_of_stream = /* @__PURE__ */ __commonJSMin(((exports, module) => {
-	var once = require_once();
-	var noop = function() {};
-	var qnt = global.Bare ? queueMicrotask : process.nextTick.bind(process);
-	var isRequest = function(stream) {
-		return stream.setHeader && typeof stream.abort === "function";
-	};
-	var isChildProcess = function(stream) {
-		return stream.stdio && Array.isArray(stream.stdio) && stream.stdio.length === 3;
 	};
-	var eos = function(stream, opts, callback) {
-		if (typeof opts === "function") return eos(stream, null, opts);
-		if (!opts) opts = {};
-		callback = once(callback || noop);
-		var ws = stream._writableState;
-		var rs = stream._readableState;
-		var readable = opts.readable || opts.readable !== false && stream.readable;
-		var writable = opts.writable || opts.writable !== false && stream.writable;
-		var cancelled = false;
-		var onlegacyfinish = function() {
-			if (!stream.writable) onfinish();
-		};
-		var onfinish = function() {
-			writable = false;
-			if (!readable) callback.call(stream);
-		};
-		var onend = function() {
-			readable = false;
-			if (!writable) callback.call(stream);
-		};
-		var onexit = function(exitCode) {
-			callback.call(stream, exitCode ? /* @__PURE__ */ new Error("exited with error code: " + exitCode) : null);
-		};
-		var onerror = function(err) {
-			callback.call(stream, err);
-		};
-		var onclose = function() {
-			qnt(onclosenexttick);
-		};
-		var onclosenexttick = function() {
-			if (cancelled) return;
-			if (readable && !(rs && rs.ended && !rs.destroyed)) return callback.call(stream, /* @__PURE__ */ new Error("premature close"));
-			if (writable && !(ws && ws.ended && !ws.destroyed)) return callback.call(stream, /* @__PURE__ */ new Error("premature close"));
-		};
-		var onrequest = function() {
-			stream.req.on("finish", onfinish);
-		};
-		if (isRequest(stream)) {
-			stream.on("complete", onfinish);
-			stream.on("abort", onclose);
-			if (stream.req) onrequest();
-			else stream.on("request", onrequest);
-		} else if (writable && !ws) {
-			stream.on("end", onlegacyfinish);
-			stream.on("close", onlegacyfinish);
-		}
-		if (isChildProcess(stream)) stream.on("exit", onexit);
-		stream.on("end", onend);
-		stream.on("finish", onfinish);
-		if (opts.error !== false) stream.on("error", onerror);
-		stream.on("close", onclose);
-		return function() {
-			cancelled = true;
-			stream.removeListener("complete", onfinish);
-			stream.removeListener("abort", onclose);
-			stream.removeListener("request", onrequest);
-			if (stream.req) stream.req.removeListener("finish", onfinish);
-			stream.removeListener("end", onlegacyfinish);
-			stream.removeListener("close", onlegacyfinish);
-			stream.removeListener("finish", onfinish);
-			stream.removeListener("exit", onexit);
-			stream.removeListener("end", onend);
-			stream.removeListener("error", onerror);
-			stream.removeListener("close", onclose);
-		};
-	};
-	module.exports = eos;
-}));
-//#endregion
-//#region ../../node_modules/.pnpm/pump@3.0.4/node_modules/pump/index.js
-var require_pump = /* @__PURE__ */ __commonJSMin(((exports, module) => {
-	var once = require_once();
-	var eos = require_end_of_stream();
-	var fs;
-	try {
-		fs = __require("fs");
-	} catch (e) {}
-	var noop = function() {};
-	var ancient = typeof process === "undefined" ? false : /^v?\.0/.test(process.version);
-	var isFn = function(fn) {
-		return typeof fn === "function";
-	};
-	var isFS = function(stream) {
-		if (!ancient) return false;
-		if (!fs) return false;
-		return (stream instanceof (fs.ReadStream || noop) || stream instanceof (fs.WriteStream || noop)) && isFn(stream.close);
-	};
-	var isRequest = function(stream) {
-		return stream.setHeader && isFn(stream.abort);
-	};
-	var destroyer = function(stream, reading, writing, callback) {
-		callback = once(callback);
-		var closed = false;
-		stream.on("close", function() {
-			closed = true;
-		});
-		eos(stream, {
-			readable: reading,
-			writable: writing
-		}, function(err) {
-			if (err) return callback(err);
-			closed = true;
-			callback();
-		});
-		var destroyed = false;
-		return function(err) {
-			if (closed) return;
-			if (destroyed) return;
-			destroyed = true;
-			if (isFS(stream)) return stream.close(noop);
-			if (isRequest(stream)) return stream.abort();
-			if (isFn(stream.destroy)) return stream.destroy();
-			callback(err || /* @__PURE__ */ new Error("stream was destroyed"));
-		};
-	};
-	var call = function(fn) {
-		fn();
-	};
-	var pipe = function(from, to) {
-		return from.pipe(to);
-	};
-	var pump = function() {
-		var streams = Array.prototype.slice.call(arguments);
-		var callback = isFn(streams[streams.length - 1] || noop) && streams.pop() || noop;
-		if (Array.isArray(streams[0])) streams = streams[0];
-		if (streams.length < 2) throw new Error("pump requires two streams per minimum");
-		var error;
-		var destroys = streams.map(function(stream, i) {
-			var reading = i < streams.length - 1;
-			return destroyer(stream, reading, i > 0, function(err) {
-				if (!error) error = err;
-				if (err) destroys.forEach(call);
-				if (reading) return;
-				destroys.forEach(call);
-				callback(error);
-			});
-		});
-		return streams.reduce(pipe);
+};
+function unpackTar(directoryPath, options = {}) {
+	const unpacker = createUnpacker(options);
+	const concurrency = options.concurrency || cpus().length || 8;
+	const opQueue = createOperationQueue(concurrency);
+	const pathCache = createPathCache(directoryPath, options, opQueue, concurrency);
+	let currentFileStream = null;
+	let currentWriteCallback = null;
+	let queuedError = null;
+	const onQueuedError = (err) => {
+		queuedError ??= err;
+		if (!writable.destroyed) writable.destroy(err);
 	};
-	module.exports = pump;
-}));
-//#endregion
-//#region src/core/fetch-packages.ts
-var import_tar_fs = (/* @__PURE__ */ __commonJSMin(((exports) => {
-	const tar = require_tar_stream();
-	const pump = require_pump();
-	const fs$1 = __require("fs");
-	const path$1 = __require("path");
-	const win32 = (global.Bare ? global.Bare.platform : process.platform) === "win32";
-	function head(list) {
-		return list.length ? list[list.length - 1] : null;
-	}
-	function processGetuid() {
-		return !global.Bare && process.getuid ? process.getuid() : -1;
-	}
-	function processUmask() {
-		return !global.Bare && process.umask ? process.umask() : 0;
-	}
-	exports.extract = function extract(cwd, opts) {
-		if (!cwd) cwd = ".";
-		if (!opts) opts = {};
-		cwd = path$1.resolve(cwd);
-		const xfs = opts.fs || fs$1;
-		const ignore = opts.ignore || opts.filter || noop;
-		const mapStream = opts.mapStream || echo;
-		const own = opts.chown !== false && !win32 && processGetuid() === 0;
-		const extract = opts.extract || tar.extract();
-		const stack = [];
-		const now = /* @__PURE__ */ new Date();
-		const umask = typeof opts.umask === "number" ? ~opts.umask : ~processUmask();
-		const strict = opts.strict !== false;
-		const validateSymLinks = opts.validateSymlinks !== false;
-		let map = opts.map || noop;
-		let dmode = typeof opts.dmode === "number" ? opts.dmode : 0;
-		let fmode = typeof opts.fmode === "number" ? opts.fmode : 0;
-		if (opts.strip) map = strip(map, opts.strip);
-		if (opts.readable) {
-			dmode |= parseInt(555, 8);
-			fmode |= parseInt(444, 8);
-		}
-		if (opts.writable) {
-			dmode |= parseInt(333, 8);
-			fmode |= parseInt(222, 8);
-		}
-		extract.on("entry", onentry);
-		if (opts.finish) extract.on("finish", opts.finish);
-		return extract;
-		function onentry(header, stream, next) {
-			header = map(header) || header;
-			header.name = normalize(header.name);
-			const name = path$1.join(cwd, path$1.join("/", header.name));
-			if (ignore(name, header)) {
-				stream.resume();
-				return next();
-			}
-			const dir = path$1.join(name, ".") === path$1.join(cwd, ".") ? cwd : path$1.dirname(name);
-			validate(xfs, dir, path$1.join(cwd, "."), function(err, valid) {
-				if (err) return next(err);
-				if (!valid) return next(/* @__PURE__ */ new Error(dir + " is not a valid path"));
-				if (header.type === "directory") {
-					stack.push([name, header.mtime]);
-					return mkdirfix(name, {
-						fs: xfs,
-						own,
-						uid: header.uid,
-						gid: header.gid,
-						mode: header.mode
-					}, stat);
+	const writable = new Writable({
+		async write(chunk, _, cb) {
+			const pendingFileOpens = [];
+			let writeError;
+			try {
+				unpacker.write(chunk);
+				if (unpacker.isEntryActive()) {
+					if (currentFileStream && currentWriteCallback) {
+						let needsDrain = false;
+						const writeCallback = currentWriteCallback;
+						while (!unpacker.isBodyComplete()) {
+							needsDrain = false;
+							if (unpacker.streamBody(writeCallback) === 0) if (needsDrain) await currentFileStream.waitDrain();
+							else return;
+						}
+						while (!unpacker.skipPadding()) return;
+						const streamToClose = currentFileStream;
+						if (streamToClose) opQueue.add(() => streamToClose.end()).catch(onQueuedError);
+						currentFileStream = null;
+						currentWriteCallback = null;
+					} else if (!unpacker.skipEntry()) return;
 				}
-				mkdirfix(dir, {
-					fs: xfs,
-					own,
-					uid: header.uid,
-					gid: header.gid,
-					mode: 493
-				}, function(err) {
-					if (err) return next(err);
-					switch (header.type) {
-						case "file": return onfile();
-						case "link": return onlink();
-						case "symlink": return onsymlink();
+				while (true) {
+					const header = unpacker.readHeader();
+					if (header === void 0 || header === null) return;
+					const transformedHeader = transformHeader(header, options);
+					if (!transformedHeader) {
+						if (!unpacker.skipEntry()) return;
+						continue;
 					}
-					if (strict) return next(/* @__PURE__ */ new Error("unsupported type for " + name + " (" + header.type + ")"));
-					stream.resume();
-					next();
-				});
-			});
-			function stat(err) {
-				if (err) return next(err);
-				utimes(name, header, function(err) {
-					if (err) return next(err);
-					if (win32) return next();
-					chperm(name, header, next);
-				});
-			}
-			function onsymlink() {
-				if (win32) return next();
-				xfs.unlink(name, function() {
-					const dst = path$1.resolve(path$1.dirname(name), header.linkname);
-					if (!inCwd(dst) && validateSymLinks) return next(/* @__PURE__ */ new Error(name + " is not a valid symlink"));
-					validateNotSymlink(xfs, dst, path$1.join(cwd, "."), function(err, valid) {
-						if (err) return next(err);
-						if (!valid && validateSymLinks) return next(/* @__PURE__ */ new Error(name + " is not a valid symlink"));
-						xfs.symlink(header.linkname, name, stat);
-					});
-				});
-			}
-			function onlink() {
-				if (win32) return next();
-				xfs.unlink(name, function() {
-					const link = path$1.join(cwd, path$1.join("/", header.linkname));
-					xfs.realpath(link, function(err, dst) {
-						if (err || !inCwd(dst)) return next(/* @__PURE__ */ new Error(name + " is not a valid hardlink"));
-						xfs.link(dst, name, function(err) {
-							if (err && err.code === "EPERM" && opts.hardlinkAsFilesFallback) {
-								stream = xfs.createReadStream(dst);
-								return onfile();
-							}
-							stat(err);
+					const outPath = await opQueue.add(() => pathCache.preparePath(transformedHeader));
+					if (outPath) {
+						const safeMode = transformedHeader.mode ? transformedHeader.mode & 511 : void 0;
+						const fileStream = createFileSink(outPath, {
+							mode: options.fmode ?? safeMode,
+							mtime: transformedHeader.mtime ?? void 0
 						});
-					});
-				});
-			}
-			function inCwd(dst) {
-				return dst === cwd || dst.startsWith(cwd + path$1.sep);
-			}
-			function onfile() {
-				const ws = xfs.createWriteStream(name);
-				const rs = mapStream(stream, header);
-				ws.on("error", function(err) {
-					rs.destroy(err);
-				});
-				pump(rs, ws, function(err) {
-					if (err) return next(err);
-					ws.on("close", stat);
-				});
+						pendingFileOpens.push(fileStream.waitDrain().catch((error) => error));
+						let needsDrain = false;
+						const writeCallback = (chunk) => {
+							const writeOk = fileStream.write(chunk);
+							if (!writeOk) needsDrain = true;
+							return writeOk;
+						};
+						while (!unpacker.isBodyComplete()) {
+							needsDrain = false;
+							if (unpacker.streamBody(writeCallback) === 0) if (needsDrain) await fileStream.waitDrain();
+							else {
+								currentFileStream = fileStream;
+								currentWriteCallback = writeCallback;
+								return;
+							}
+						}
+						while (!unpacker.skipPadding()) {
+							currentFileStream = fileStream;
+							currentWriteCallback = writeCallback;
+							return;
+						}
+						opQueue.add(() => fileStream.end()).catch(onQueuedError);
+					} else if (!unpacker.skipEntry()) return;
+				}
+			} catch (err) {
+				writeError = err;
+			} finally {
+				cb((pendingFileOpens.length ? (await Promise.all(pendingFileOpens)).find((error) => error) : void 0) ?? writeError);
 			}
-		}
-		function utimesParent(name, cb) {
-			let top;
-			while ((top = head(stack)) && name.slice(0, top[0].length) !== top[0]) stack.pop();
-			if (!top) return cb();
-			xfs.utimes(top[0], now, top[1], cb);
-		}
-		function utimes(name, header, cb) {
-			if (opts.utimes === false) return cb();
-			if (header.type === "directory") return xfs.utimes(name, now, header.mtime, cb);
-			if (header.type === "symlink") return utimesParent(name, cb);
-			xfs.utimes(name, now, header.mtime, function(err) {
-				if (err) return cb(err);
-				utimesParent(name, cb);
-			});
-		}
-		function chperm(name, header, cb) {
-			const link = header.type === "symlink";
-			const chmod = link ? xfs.lchmod : xfs.chmod;
-			const chown = link ? xfs.lchown : xfs.chown;
-			if (!chmod) return cb();
-			const mode = (header.mode | (header.type === "directory" ? dmode : fmode)) & umask;
-			if (chown && own) chown.call(xfs, name, header.uid, header.gid, onchown);
-			else onchown(null);
-			function onchown(err) {
-				if (err) return cb(err);
-				if (!chmod) return cb();
-				chmod.call(xfs, name, mode, cb);
+		},
+		async final(cb) {
+			try {
+				unpacker.end();
+				unpacker.validateEOF();
+				await pathCache.ready();
+				await opQueue.onIdle();
+				if (queuedError) throw queuedError;
+				await pathCache.checkSymlinks();
+				await pathCache.applyLinks();
+				cb();
+			} catch (err) {
+				cb(err);
 			}
-		}
-		function mkdirfix(name, opts, cb) {
-			xfs.stat(name, function(err) {
-				if (!err) return cb(null);
-				if (err.code !== "ENOENT") return cb(err);
-				xfs.mkdir(name, {
-					mode: opts.mode,
-					recursive: true
-				}, function(err, made) {
-					if (err) return cb(err);
-					chperm(name, opts, cb);
-				});
-			});
-		}
-	};
-	function validateNotSymlink(fs, name, root, cb) {
-		if (name === root) return cb(null, true);
-		if (!name.startsWith(root + path$1.sep)) return cb(null, false);
-		fs.lstat(name, function(err, st) {
-			if (err && err.code !== "ENOENT" && err.code !== "EPERM") return cb(err);
-			if (err || !st.isSymbolicLink()) return validateNotSymlink(fs, path$1.join(name, ".."), root, cb);
-			cb(null, false);
-		});
-	}
-	function validate(fs, name, root, cb) {
-		if (name === root) return cb(null, true);
-		fs.lstat(name, function(err, st) {
-			if (err && err.code !== "ENOENT" && err.code !== "EPERM") return cb(err);
-			if (err || st.isDirectory()) return validate(fs, path$1.join(name, ".."), root, cb);
-			cb(null, false);
-		});
-	}
-	function noop() {}
-	function echo(name) {
-		return name;
-	}
-	function normalize(name) {
-		return win32 ? name.replace(/\\/g, "/").replace(/[:?<>|]/g, "_") : name;
-	}
-	function strip(map, level) {
-		return function(header) {
-			header.name = header.name.split("/").slice(level).join("/");
-			const linkname = header.linkname;
-			if (linkname && (header.type === "link" || path$1.isAbsolute(linkname))) header.linkname = linkname.split("/").slice(level).join("/");
-			return map(header);
-		};
-	}
-})))();
+		},
+		destroy(error, callback) {
+			(async () => {
+				if (currentFileStream) {
+					currentFileStream.destroy(error ?? void 0);
+					currentFileStream = null;
+					currentWriteCallback = null;
+				}
+				await opQueue.onIdle();
+			})().then(() => callback(error ?? null), (e) => callback(error ?? (e instanceof Error ? e : /* @__PURE__ */ new Error("Stream destroyed"))));
+		}
+	});
+	return writable;
+}
+//#endregion
+//#region src/core/fetch-packages.ts
 const NODE_MODULES = fileURLToPath(new URL("../../node_modules", import.meta.url));
 function verifyPackage(addonPkg, specifier) {
 	const peerDeps = { ...addonPkg.peerDependencies };
@@ -10847,10 +9161,7 @@ async function downloadPackage(options) {
 	const tarballUrl = pkg.dist.tarball;
 	const data = await fetch(tarballUrl);
 	if (!data.body) throw new Error(`Unexpected response: '${tarballUrl}' responded with no body`);
-	await pipeline(data.body, createGunzip(), (0, import_tar_fs.extract)(NODE_MODULES, { map: (header) => {
-		header.name = header.name.replace("package", pkg.name);
-		return header;
-	} }));
+	await pipeline(data.body, createGunzip(), unpackTar(path.join(NODE_MODULES, pkg.name), { strip: 1 }));
 	return await importAddonCode(pkg.name, pkg.version);
 }
 async function importAddonCode(pkgName, pkgVersion) {
@@ -10894,48 +9205,6 @@ async function getPackageJSON(ref) {
 	};
 }
 //#endregion
-//#region src/core/formatFiles.ts
-async function formatFiles(options) {
-	if (options.filesToFormat.length === 0) return;
-	const { start, stop } = vt();
-	start("Formatting modified files");
-	const args = [
-		"--write",
-		"--ignore-unknown",
-		...options.filesToFormat
-	];
-	let result = await run("prettier", args, options.cwd);
-	if (result.notFound) {
-		const cmd = resolveCommand(options.packageManager, "execute-local", ["prettier", ...args]);
-		result = await run(cmd.command, cmd.args, options.cwd);
-	}
-	if (result.error !== void 0) {
-		stop("Failed to format files");
-		R$1.error(result.error);
-		return;
-	}
-	stop("Successfully formatted modified files");
-}
-async function run(command, args, cwd) {
-	try {
-		await z(command, args, {
-			nodeOptions: {
-				cwd,
-				stdio: "pipe"
-			},
-			throwOnError: true
-		});
-		return {};
-	} catch (e) {
-		if (e?.code === "ENOENT") return {
-			notFound: true,
-			error: `${command} not found`
-		};
-		const output = e?.output;
-		return { error: [output?.stderr, output?.stdout].filter(Boolean).join("\n").trim() || (e instanceof Error ? e.message : "unknown error") };
-	}
-}
-//#endregion
 //#region src/core/package-manager.ts
 const AGENT_NAMES = AGENTS.filter((agent) => !agent.includes("@"));
 const installOption = new Option("--install <package-manager>", "installs dependencies with a specified package manager").choices(AGENT_NAMES);
@@ -10943,7 +9212,7 @@ async function packageManagerPrompt(cwd) {
 	const agent = (await detect({ cwd }))?.name ?? getUserAgent();
 	if (!V.stdout.isTTY) return agent;
 	const pm = await Ee({
-		message: "Which package manager do you want to install dependencies with?",
+		message: "Detected package managers. Which one should we use to install dependencies?",
 		options: [{
 			label: "None",
 			value: void 0
@@ -11034,91 +9303,16 @@ function addPnpmAllowBuilds(cwd, packageManager, ...packages) {
 	const filePath = found ?? path.join(cwd, "pnpm-workspace.yaml");
 	const content = found ? fs.readFileSync(found, "utf-8") : "";
 	const newContent = pnpm.allowBuilds(...packages)(content);
-	if (newContent !== content) fs.writeFileSync(filePath, newContent, "utf-8");
-}
-//#endregion
-//#region src/core/verifiers.ts
-function verifyCleanWorkingDirectory(cwd, gitCheck) {
-	const verifications = [];
-	if (gitCheck) verifications.push({
-		name: "clean working directory",
-		run: async () => {
-			try {
-				const { stdout } = await promisify(exec)("git status --short", { cwd });
-				if (stdout) return {
-					success: false,
-					message: "Uncommited changes found"
-				};
-				return {
-					success: true,
-					message: void 0
-				};
-			} catch {
-				return {
-					success: true,
-					message: "Not a git repository"
-				};
-			}
-		}
-	});
-	return verifications;
-}
-function verifyUnsupportedAddons(addons, setupResults) {
-	const verifications = [];
-	verifications.push({
-		name: "unsupported add-ons",
-		run: () => {
-			const reasons = addons.flatMap((a) => setupResults[a.id].unsupported.map((reason) => ({
-				id: a.id,
-				reason
-			})));
-			if (reasons.length === 0) return {
-				success: true,
-				message: void 0
-			};
-			throw new UnsupportedError(reasons);
-		}
-	});
-	return verifications;
+	if (newContent && newContent !== content) fs.writeFileSync(filePath, newContent, "utf-8");
 }
 //#endregion
 //#region src/core/workspace.ts
-const deprecatedFiles = {
-	prettierignore: ".prettierignore",
-	prettierrc: ".prettierrc",
-	eslintConfig: "eslint.config.js",
-	vscodeSettings: ".vscode/settings.json",
-	vscodeExtensions: ".vscode/extensions.json"
-};
-/**
-* Adds deprecated file properties as non-enumerable getters so they don't trigger on spread
-* Once we remove these deprecatedFiles, we can get rid of addDeprecatedFileProperties
-*/
-function addDeprecatedFileProperties(file, svelteConfig) {
-	for (const [key, value] of Object.entries(deprecatedFiles)) Object.defineProperty(file, key, {
-		get() {
-			svDeprecated(`use the string \`"${value}"\` instead of \`file.${key}\``);
-			return value;
-		},
-		enumerable: false
-	});
-	Object.defineProperty(file, "svelteConfig", {
-		get() {
-			svDeprecated("use `svelteConfig` from `@sveltejs/sv-utils` instead of `file.svelteConfig` (the config may live in `vite.config.{js,ts}`)");
-			return svelteConfig;
-		},
-		enumerable: false
-	});
-	return file;
-}
 async function createWorkspace({ cwd, packageManager, override }) {
 	const resolvedCwd = path.resolve(cwd);
 	const typeConfig = any([filePaths.jsconfig, filePaths.tsconfig], { cwd });
 	const typescript = typeConfig?.endsWith(filePaths.tsconfig) ?? false;
 	const viteConfigPath = path.join(resolvedCwd, filePaths.viteConfigTS);
 	const viteConfig = fs.existsSync(viteConfigPath) ? filePaths.viteConfigTS : filePaths.viteConfig;
-	const svelteConfigPath = path.join(resolvedCwd, filePaths.svelteConfigTS);
-	const svelteConfig = fs.existsSync(svelteConfigPath) ? filePaths.svelteConfigTS : filePaths.svelteConfig;
 	let dependencies = {};
 	if (override?.dependencies) dependencies = override.dependencies;
 	else {
@@ -11155,7 +9349,7 @@ async function createWorkspace({ cwd, packageManager, override }) {
 		cwd: resolvedCwd,
 		packageManager: packageManager ?? await detectPackageManager(cwd),
 		language: typescript ? "ts" : "js",
-		file: addDeprecatedFileProperties({
+		file: {
 			viteConfig,
 			typeConfig,
 			stylesheet,
@@ -11173,7 +9367,7 @@ async function createWorkspace({ cwd, packageManager, override }) {
 				if (resolvedCwd.includes(".test-output") && !found.includes(".test-output")) return filename;
 				return path.relative(resolvedCwd, found);
 			}
-		}, svelteConfig),
+		},
 		isKit,
 		directory,
 		dependencyVersion: (pkg) => dependencies[pkg]
@@ -11230,6 +9424,129 @@ function parseKitOptions(cwd) {
 	};
 }
 //#endregion
+//#region src/core/formatFiles.ts
+async function formatFiles(options) {
+	if (options.filesToFormat.length === 0) return;
+	if (options.strategy === "project-script-then-files-only") {
+		const script = findFormatScript(options.cwd);
+		if (script) {
+			const packageManager = await detectPackageManager(script.dir);
+			const cmd = resolveCommand(packageManager, "run", [script.name]);
+			await withSpinner(`Running ${packageManager} run ${script.name}`, () => run(cmd.command, cmd.args, script.dir));
+			return;
+		}
+	}
+	const args = [
+		"--write",
+		"--ignore-unknown",
+		...options.filesToFormat
+	];
+	await withSpinner("Formatting modified files", async () => {
+		let result = await run("prettier", args, options.cwd);
+		if (result.notFound) {
+			const cmd = resolveCommand(options.packageManager, "execute-local", ["prettier", ...args]);
+			result = await run(cmd.command, cmd.args, options.cwd);
+		}
+		return result;
+	});
+}
+/** Nearest dir from `cwd` up to the workspace root with a `format` or `fmt` package.json script. */
+function findFormatScript(cwd) {
+	const workspaceRoot = findWorkspaceRoot(cwd);
+	let directory = path.resolve(cwd);
+	const { root } = path.parse(directory);
+	while (directory && directory.length >= workspaceRoot.length) {
+		if (fs.existsSync(path.join(directory, "package.json"))) {
+			const { data } = loadPackageJson(directory);
+			if (data.scripts?.format) return {
+				dir: directory,
+				name: "format"
+			};
+			if (data.scripts?.fmt) return {
+				dir: directory,
+				name: "fmt"
+			};
+		}
+		if (directory === root) break;
+		directory = path.dirname(directory);
+	}
+}
+async function withSpinner(startMsg, task) {
+	const { start, stop } = vt();
+	start(startMsg);
+	const { error } = await task();
+	if (error !== void 0) {
+		stop("Failed to format files");
+		R$1.error(error);
+		return;
+	}
+	stop("Successfully formatted files");
+}
+async function run(command, args, cwd) {
+	try {
+		await z(command, args, {
+			nodeOptions: {
+				cwd,
+				stdio: "pipe"
+			},
+			throwOnError: true
+		});
+		return {};
+	} catch (e) {
+		if (e?.code === "ENOENT") return {
+			notFound: true,
+			error: `${command} not found`
+		};
+		const output = e?.output;
+		return { error: [output?.stderr, output?.stdout].filter(Boolean).join("\n").trim() || (e instanceof Error ? e.message : "unknown error") };
+	}
+}
+//#endregion
+//#region src/core/verifiers.ts
+function verifyCleanWorkingDirectory(cwd, gitCheck) {
+	const verifications = [];
+	if (gitCheck) verifications.push({
+		name: "clean working directory",
+		run: async () => {
+			try {
+				const { stdout } = await promisify(exec)("git status --short", { cwd });
+				if (stdout) return {
+					success: false,
+					message: "Uncommited changes found"
+				};
+				return {
+					success: true,
+					message: void 0
+				};
+			} catch {
+				return {
+					success: true,
+					message: "Not a git repository"
+				};
+			}
+		}
+	});
+	return verifications;
+}
+function verifyUnsupportedAddons(addons, setupResults) {
+	const verifications = [];
+	verifications.push({
+		name: "unsupported add-ons",
+		run: () => {
+			const reasons = addons.flatMap((a) => setupResults[a.id].unsupported.map((reason) => ({
+				id: a.id,
+				reason
+			})));
+			if (reasons.length === 0) return {
+				success: true,
+				message: void 0
+			};
+			throw new UnsupportedError(reasons);
+		}
+	});
+	return verifications;
+}
+//#endregion
 //#region src/create/playground.ts
 function validatePlaygroundUrl(link) {
 	try {
@@ -11280,6 +9597,7 @@ function detectPlaygroundDependencies(files) {
 	const packages = /* @__PURE__ */ new Map();
 	const excludedPrefixes = [
 		"$",
+		"#",
 		"node:",
 		"svelte",
 		"@sveltejs/"
@@ -11358,11 +9676,11 @@ function setupPlaygroundProject(url, playground, cwd, installDependencies) {
 	svelte.ensureScript(ast);
 	js.imports.addDefault(ast.instance.content, {
 		as: "App",
-		from: `$lib/playground/${mainFile.name}`
+		from: `#lib/playground/${mainFile.name}`
 	});
 	js.imports.addDefault(ast.instance.content, {
 		as: "PlaygroundLayout",
-		from: `$lib/PlaygroundLayout.svelte`
+		from: `#lib/PlaygroundLayout.svelte`
 	});
 	svelte.addFragment(ast, `<PlaygroundLayout>
 		<App />
@@ -11654,7 +9972,8 @@ async function createProject(cwd, options) {
 		if (depsInstalled) await formatFiles({
 			packageManager,
 			cwd: projectPath,
-			filesToFormat: addOnSuccessfulAddons.some((addon) => addon.addon.id === "prettier") ? ["."] : addOnFilesToFormat
+			filesToFormat: addOnSuccessfulAddons.some((addon) => addon.addon.id === "prettier") ? ["."] : addOnFilesToFormat,
+			strategy: "files-only"
 		});
 	}
 	return {
@@ -11708,8 +10027,7 @@ async function createVirtualWorkspace({ cwd, template, type }) {
 		language: type === "typescript" ? "ts" : "js",
 		file: {
 			...tentativeWorkspace.file,
-			viteConfig: type === "typescript" ? filePaths.viteConfigTS : filePaths.viteConfig,
-			svelteConfig: filePaths.svelteConfig
+			viteConfig: type === "typescript" ? filePaths.viteConfigTS : filePaths.viteConfig
 		}
 	};
 }
@@ -12024,26 +10342,7 @@ async function promptAddonQuestions({ options, loadedAddons, workspace }) {
 		}
 	}
 	const addonDefinitions = addons.map((a) => a.addon);
-	const verifications = [...verifyCleanWorkingDirectory(options.cwd, options.gitCheck), ...verifyUnsupportedAddons(addonDefinitions, setupResults)];
-	const fails = [];
-	for (const verification of verifications) {
-		const { message, success } = await verification.run();
-		if (!success) fails.push({
-			name: verification.name,
-			message
-		});
-	}
-	if (fails.length > 0) {
-		Ce(`- ${fails.map(({ name, message }) => color.warning(`${name} (${message})`)).join("\n- ")}`, "Verifications not met", { format: (line) => line });
-		const force = await le({
-			message: "Verifications failed. Do you wish to continue?",
-			initialValue: false
-		});
-		if (R$2(force) || !force) {
-			ge("Operation cancelled.");
-			V.exit(1);
-		}
-	}
+	await runAndValidateVerifications([...verifyCleanWorkingDirectory(options.cwd, options.gitCheck), ...verifyUnsupportedAddons(addonDefinitions, setupResults)]);
 	for (const loaded of addons) {
 		const addon = loaded.addon;
 		const addonId = addon.id;
@@ -12157,7 +10456,8 @@ async function runAddonsApply({ answers, options, loadedAddons, setupResults, wo
 		if (depsInstalled) await formatFiles({
 			packageManager,
 			cwd: options.cwd,
-			filesToFormat
+			filesToFormat,
+			strategy: "files-only"
 		});
 	}
 	const nextSteps = getNextSteps(successfulAddons, workspace, answers, setupResults);
@@ -12351,20 +10651,24 @@ function alphabetizeRecord(obj) {
 	for (const [key, value] of Object.entries(obj).sort(([a], [b]) => a.localeCompare(b))) ordered[key] = value;
 	return ordered;
 }
-function updatePackages(dependencies, cwd) {
-	const { source } = loadPackageJson(cwd);
-	const { data, generateCode } = parse.json(source);
-	for (const dependency of dependencies) if (dependency.dev) {
-		data.devDependencies ??= {};
-		data.devDependencies[dependency.pkg] = dependency.version;
-	} else {
-		data.dependencies ??= {};
-		data.dependencies[dependency.pkg] = dependency.version;
-	}
-	if (data.dependencies) data.dependencies = alphabetizeRecord(data.dependencies);
-	if (data.devDependencies) data.devDependencies = alphabetizeRecord(data.devDependencies);
-	saveFile(cwd, filePaths.packageJson, generateCode());
-	return filePaths.packageJson;
+function updatePackages(dependencies, sv) {
+	if (dependencies.length === 0) return;
+	const pkgPath = filePaths.packageJson;
+	sv.file(pkgPath, transforms.json(({ content, data }) => {
+		if (!content) throw new Error(`Invalid workspace: missing '${pkgPath}'`);
+		let modified = false;
+		for (const { dev, pkg, version } of dependencies) {
+			const dependency = dev ? "devDependencies" : "dependencies";
+			data[dependency] ??= {};
+			if (data[dependency][pkg] !== version) {
+				modified = true;
+				data[dependency][pkg] = version;
+			}
+		}
+		if (!modified) return false;
+		if (data.dependencies) data.dependencies = alphabetizeRecord(data.dependencies);
+		if (data.devDependencies) data.devDependencies = alphabetizeRecord(data.devDependencies);
+	}));
 }
 async function add({ addons, cwd, options, packageManager = "npm" }) {
 	const workspace = await createWorkspace({
@@ -12453,31 +10757,88 @@ async function setupAddons(loadedAddons, workspace) {
 	return setupResults;
 }
 async function runAddon({ addon, loaded, multiple, workspace, workspaceOptions }) {
-	const files = /* @__PURE__ */ new Set();
+	let modifiedFiles = /* @__PURE__ */ new Set();
 	const options = { ...workspaceOptions };
 	for (const [id, question] of Object.entries(addon.options)) if (question.condition?.(options) !== false) options[id] ??= question.default;
+	const { sv, finalize } = prepareSvApi(workspace, { executeOutputPrefix: multiple ? `${addon.id}: ` : "" });
+	const cancels = [];
+	try {
+		await addon.run({
+			cancel: (reason) => {
+				cancels.push(reason);
+			},
+			...workspace,
+			options,
+			sv
+		});
+	} catch (err) {
+		const msg = err instanceof Error ? err.message : String(err);
+		throw new Error(`Add-on '${addon.id}' failed during run: ${msg}\n\n${getErrorHint(loaded.reference.source)}`, { cause: err });
+	}
+	if (cancels.length === 0) ({modifiedFiles} = finalize());
+	return {
+		files: Array.from(modifiedFiles),
+		cancels
+	};
+}
+function editFile(file, edit, workspace, modifiedFiles, unmodifiedFiles, options, include) {
+	try {
+		const exists = fileExists(workspace.cwd, file);
+		if (exists && !fs.statSync(path.resolve(workspace.cwd, file)).isFile()) return;
+		const content = exists ? loadFile(workspace.cwd, file) : "";
+		if (include === void 0 ? false : !include(content)) return;
+		const editedContent = edit(content);
+		if (editedContent === "" || editedContent === false) return;
+		if (options.filesFilter && !path.matchesGlob(file, options.filesFilter)) {
+			unmodifiedFiles.add(file);
+			return;
+		}
+		const diffMinimizedEditedContent = minimizeDiff(content, editedContent);
+		file = saveFile(workspace.cwd, file, diffMinimizedEditedContent, options.saveFileInfix);
+		modifiedFiles.add(file);
+	} catch (e) {
+		if (e instanceof Error) e.message = `Unable to process '${file}'. Reason: ${e.message}`;
+		throw e;
+	}
+}
+function prepareSvApi(workspace, options = {
+	filesFilter: void 0,
+	executeOutputPrefix: void 0,
+	saveFileInfix: void 0,
+	additionalExcludes: void 0
+}) {
 	const dependencies = [];
+	const modifiedFiles = /* @__PURE__ */ new Set();
+	const unmodifiedFiles = /* @__PURE__ */ new Set();
 	const sv = {
 		file: (path, edit) => {
-			try {
-				const content = fileExists(workspace.cwd, path) ? loadFile(workspace.cwd, path) : "";
-				const editedContent = edit(content);
-				if (editedContent === "" || editedContent === false) return content;
-				saveFile(workspace.cwd, path, editedContent);
-				files.add(path);
-			} catch (e) {
-				if (e instanceof Error) {
-					e.message = `Unable to process '${path}'. Reason: ${e.message}`;
-					throw e;
-				}
-				throw e;
+			editFile(path, edit, workspace, modifiedFiles, unmodifiedFiles, options);
+		},
+		files: (opts, edit) => {
+			const { include, exclude } = opts;
+			const globbedFiles = fs.globSync(include, {
+				cwd: workspace.cwd,
+				exclude: [
+					"node_modules/**",
+					"**/node_modules/**",
+					".*/**",
+					"**/.*/**",
+					"build/**",
+					"dist/**",
+					...options.additionalExcludes ?? [],
+					...exclude ?? []
+				]
+			});
+			for (const file of globbedFiles) {
+				if (options.filesFilter && !path.matchesGlob(file, options.filesFilter)) continue;
+				const singleFileEdit = (content) => edit(content, file);
+				editFile(file, singleFileEdit, workspace, modifiedFiles, unmodifiedFiles, options, opts.where);
 			}
 		},
 		execute: async (commandArgs, stdio) => {
 			const { command, args } = resolveCommand(workspace.packageManager, "execute", commandArgs);
-			const addonPrefix = multiple ? `${addon.id}: ` : "";
 			const executedCommand = [command, ...args].join(" ");
-			if (!TESTING) R$1.step(`${addonPrefix}Running external command ${color.optional(`(${executedCommand})`)}`);
+			if (!TESTING) R$1.step(`${options?.executeOutputPrefix}Running external command ${color.optional(`(${executedCommand})`)}`);
 			if (workspace.packageManager === "npm") args.unshift("--yes");
 			try {
 				await z(command, args, {
@@ -12504,34 +10865,17 @@ async function runAddon({ addon, loaded, multiple, workspace, workspaceOptions }
 				version,
 				dev: true
 			});
-		},
-		/** @deprecated use `pnpm.allowBuilds` from `@sveltejs/sv-utils` instead */
-		pnpmBuildDependency: (pkg) => {
-			svDeprecated("use `pnpm.allowBuilds` from `@sveltejs/sv-utils` instead of `sv.pnpmBuildDependency`");
-			addPnpmAllowBuilds(workspace.cwd, workspace.packageManager, pkg);
 		}
 	};
-	const cancels = [];
-	try {
-		await addon.run({
-			cancel: (reason) => {
-				cancels.push(reason);
-			},
-			...workspace,
-			options,
-			sv
-		});
-	} catch (err) {
-		const msg = err instanceof Error ? err.message : String(err);
-		throw new Error(`Add-on '${addon.id}' failed during run: ${msg}\n\n${getErrorHint(loaded.reference.source)}`, { cause: err });
-	}
-	if (cancels.length === 0) {
-		const pkgPath = updatePackages(dependencies, workspace.cwd);
-		files.add(pkgPath);
-	}
 	return {
-		files: Array.from(files),
-		cancels
+		sv,
+		finalize: () => {
+			updatePackages(dependencies, sv);
+			return {
+				modifiedFiles,
+				unmodifiedFiles
+			};
+		}
 	};
 }
 /**
@@ -12560,4 +10904,4 @@ function orderAddons(addons, setupResults) {
 	return ordered;
 }
 //#endregion
-export { __toESM as S, name as _, detectPackageManager as a, __commonJSMin as b, defineAddonOptions as c, Command as d, R as f, helpConfig as g, forwardExitCode as h, addPnpmAllowBuilds as i, from as l, create$1 as m, add$1 as n, officialAddons$1 as o, z as p, create as r, defineAddon as s, add as t, program as u, version as v, __require as x, svDeprecated as y };
+export { Command as A, name as B, pipe as C, union as D, transform as E, forwardExitCode as F, ge as G, Ce as H, helpConfig as I, we as J, le as K, normalizePosix as L, z as M, create$1 as N, from as O, errorAndExit as P, __toESM as Q, runAndValidateVerifications as R, picklist as S, string as T, Ee as U, version as V, R$1 as W, __commonJSMin as X, R$2 as Y, __require as Z, array as _, verifyCleanWorkingDirectory as a, optional as b, AGENT_NAMES as c, installDependencies as d, installOption as f, defineAddonOptions as g, defineAddon as h, create as i, R as j, program as k, addPnpmAllowBuilds as l, officialAddons$1 as m, prepareSvApi as n, formatFiles as o, packageManagerPrompt as p, vt as q, add$1 as r, createWorkspace as s, add as t, detectPackageManager as u, boolean as v, strictObject as w, parse$1 as x, literal as y, runCommand as z };