@kubb/studio 5.11.3 → 5.11.4

package/dist/index.d.cts

@@ -1,4 +1,4 @@
-import { D as InstalledExtensions, P as PublishedSnapshot, W as SnapshotUploadMetadata, a as AgentConnectInfo, c as AgentPermissions, d as ConfigEditOutcome, s as AgentPermission, u as ConfigEdit } from "./protocol-DpxvWX9E.cjs";
+import { E as InstalledExtensions, N as PublishedSnapshot, U as SnapshotUploadMetadata, a as AgentConnectInfo, c as AgentPermissions, d as ConfigEditOutcome, s as AgentPermission, u as ConfigEdit } from "./protocol-a_DcTFba.cjs";
 import { Config, Hookable, KubbHooks } from "@kubb/core";
 //#region src/connect.d.ts
 /**

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { D as InstalledExtensions, P as PublishedSnapshot, W as SnapshotUploadMetadata, a as AgentConnectInfo, c as AgentPermissions, d as ConfigEditOutcome, s as AgentPermission, u as ConfigEdit } from "./protocol-DpxvWX9E.js";
+import { E as InstalledExtensions, N as PublishedSnapshot, U as SnapshotUploadMetadata, a as AgentConnectInfo, c as AgentPermissions, d as ConfigEditOutcome, s as AgentPermission, u as ConfigEdit } from "./protocol-a_DcTFba.js";
 import { Config, Hookable, KubbHooks } from "@kubb/core";
 //#region src/connect.d.ts
 /**

package/dist/index.js

@@ -1,14 +1,14 @@
-import { AGENT_INSTANCE_HEADER, AGENT_SOCKET_PATH, AgentCloseCode, AgentMessage, AgentPermission, FileSource, MAX_SNAPSHOT_BYTES, generationEventTypes } from "./protocol.js";
+import { AGENT_INSTANCE_HEADER, AGENT_SOCKET_PATH, AgentCloseCode, AgentMessage, AgentPermission, MAX_SNAPSHOT_BYTES, generationEventTypes } from "./protocol.js";
 import { createRequire } from "node:module";
 import { createHash, hash, randomUUID } from "node:crypto";
-import { mkdir, mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import path, { dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
 import process$1 from "node:process";
 import { setTimeout as setTimeout$1 } from "node:timers/promises";
 import { pathToFileURL } from "node:url";
 import { existsSync } from "node:fs";
-import { Diagnostics, Hookable, cacheStorage, createKubb, fsStorage, getInputKind, isPackageName, memoryStorage, readInstalledPackages, resolveCacheDir, resolveMeta } from "@kubb/core";
+import { mkdir, mkdir as mkdir$1, mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
+import { Diagnostics, Hookable, cacheStorage, createKubb, fsStorage, getInputKind, isPackageName, readInstalledPackages, resolveCacheDir, resolveMeta } from "@kubb/core";
 import { RpcTarget, newWebSocketRpcSession } from "capnweb";
 import { detectCodeFormat, parseExpression, parseModule } from "magicast";
 import { structuredPatch } from "diff";
@@ -117,6 +117,27 @@ async function read(path) {
 	return readFile(path, { encoding: "utf8" });
 }
 /**
+* Writes UTF-8 content verbatim, including empty files and surrounding whitespace.
+* Uses Bun.write under Bun and creates missing parent directories under either runtime.
+*
+* @example
+* await writeRaw('./cache/output.ts', '  // keep these bytes\n\n')
+*/
+async function writeRaw(path, content) {
+	const resolved = resolve(path);
+	if (runtime.isBun) {
+		await Bun.write(resolved, content);
+		return;
+	}
+	try {
+		await writeFile(resolved, content, { encoding: "utf-8" });
+	} catch (error) {
+		if (error.code !== "ENOENT") throw error;
+		await mkdir(dirname(resolved), { recursive: true });
+		await writeFile(resolved, content, { encoding: "utf-8" });
+	}
+}
+/**
 * Resolves to `true` when `path` is `parent` itself or nested inside it. Both sides are resolved
 * to absolute paths first, so relative and `..`-containing inputs compare correctly.
 *
@@ -175,7 +196,7 @@ function getElapsedMs(hrStart) {
 }
 //#endregion
 //#region package.json
-var version = "5.11.3";
+var version = "5.11.4";
 //#endregion
 //#region src/resolveConfig.ts
 /**
@@ -1371,21 +1392,20 @@ const hashOf = (content) => createHash("sha1").update(content).digest("hex").sli
 /**
 * The bytes `entries` keep on disk: output, written files, and kept input.
 */
-const totalBytes = (entries) => entries.reduce((sum, { output, disk, inputBytes }) => sum + output.bytes + (disk?.bytes ?? 0) + (inputBytes ?? 0), 0);
+const totalBytes = (entries) => entries.reduce((sum, { output, inputBytes }) => sum + output.bytes + (inputBytes ?? 0), 0);
 function positiveNumber(value) {
 	const parsed = Number(value);
 	return value && Number.isFinite(parsed) && parsed > 0 ? parsed : void 0;
 }
 /**
 * How many generations an agent keeps and how large they may get, read from
-* `KUBB_AGENT_MAX_GENERATIONS`, `KUBB_AGENT_MAX_GENERATIONS_MB` and `KUBB_AGENT_MAX_SNAPSHOT_MB`.
+* `KUBB_AGENT_MAX_GENERATIONS` and `KUBB_AGENT_MAX_GENERATIONS_MB`.
 * An unset or invalid value keeps the default.
 */
 function resolveGenerationLimits() {
 	return {
 		maxCount: Math.max(1, Math.floor(positiveNumber(process$1.env.KUBB_AGENT_MAX_GENERATIONS) ?? 8)),
-		maxMb: positiveNumber(process$1.env.KUBB_AGENT_MAX_GENERATIONS_MB) ?? 100,
-		maxSnapshotMb: positiveNumber(process$1.env.KUBB_AGENT_MAX_SNAPSHOT_MB) ?? 50
+		maxMb: positiveNumber(process$1.env.KUBB_AGENT_MAX_GENERATIONS_MB) ?? 100
 	};
 }
 /**
@@ -1432,7 +1452,7 @@ async function generate({ config, hooks, signal, allowExec }) {
 	};
 }
 /**
-* What the output directory holds on disk before a run. `undefined` when `outputPath` is not a real
+* What the output directory holds when the editor connects. `undefined` when `outputPath` is not a real
 * subdirectory of `root` (listing the root would take in every source file) or holds more than `maxFiles`.
 */
 async function listDisk({ root, outputPath, maxFiles }) {
@@ -1449,38 +1469,11 @@ async function listDisk({ root, outputPath, maxFiles }) {
 		paths: new Set(paths)
 	};
 }
-async function readDiskFiles({ files: disk, paths, cursor = 0, limit }) {
-	const files = {};
-	const pages = {};
-	await inParallel({
-		items: paths.filter((path) => disk.paths.has(path)),
-		limit: READ_CONCURRENCY,
-		run: async (path) => {
-			const content = await disk.storage.readItem(resolve(disk.root, path));
-			if (content === null) return;
-			if (limit === void 0) {
-				files[path] = content;
-				return;
-			}
-			const lines = content.split(/\r\n|\r|\n/);
-			const end = Math.min(cursor + limit, lines.length);
-			files[path] = lines.slice(cursor, end).join("\n");
-			pages[path] = {
-				nextCursor: end < lines.length ? end : null,
-				totalLines: lines.length
-			};
-		}
-	});
-	return limit === void 0 ? { files } : {
-		files,
-		pages
-	};
-}
 /**
 * Keeps recent generations by job id in `storage`, with an index next to them so a store on disk
 * survives a restart. A generation is only ever looked up by its job id, so on a pooled sandbox one
-* tenant never reaches another's output. The oldest go past `maxCount` or `maxMb`, but the newest
-* always stays.
+* tenant never reaches another's output. Initial disk output and generated jobs each get their
+* own `maxCount` and `maxMb` budget. Each budget always keeps its newest entry.
 */
 function createGenerationStore({ storage, maxCount, maxMb, ttlMs, now = Date.now }) {
 	let index;
@@ -1499,7 +1492,7 @@ function createGenerationStore({ storage, maxCount, maxMb, ttlMs, now = Date.now
 	/**
 	* Copies `files` into the store as one set of `jobId`. Above `maxSetMb` only the hashes are kept.
 	*/
-	async function keep({ jobId, source, files, maxSetMb, normalize = source === FileSource.OUTPUT }) {
+	async function keep({ jobId, files, maxSetMb }) {
 		const maxSetBytes = maxSetMb * MB;
 		const hashes = {};
 		let bytes = 0;
@@ -1510,14 +1503,13 @@ function createGenerationStore({ storage, maxCount, maxMb, ttlMs, now = Date.now
 				if (path.split("/").includes("..")) return;
 				const content = await files.storage.readItem(resolve(files.root, path));
 				if (content === null) return;
-				if (normalize && !content.trim()) return;
-				hashes[path] = hashOf(normalize ? `${content.trim()}\n` : content);
+				hashes[path] = hashOf(content);
 				bytes += Buffer.byteLength(content);
-				if (bytes <= maxSetBytes) await storage.writeItem(`${dirOf(jobId)}${source}/${path}`, content);
+				if (bytes <= maxSetBytes) await storage.writeItem(`${dirOf(jobId)}output/${path}`, content);
 			}
 		});
 		if (bytes > maxSetBytes) {
-			await storage.empty(`${dirOf(jobId)}${source}/`);
+			await storage.empty(`${dirOf(jobId)}output/`);
 			return {
 				paths: [],
 				hashes,
@@ -1533,10 +1525,50 @@ function createGenerationStore({ storage, maxCount, maxMb, ttlMs, now = Date.now
 	async function drop(jobId) {
 		await storage.empty(dirOf(jobId));
 	}
+	async function add(generation) {
+		const current = await load();
+		for (const expired of current.filter((entry) => !isLive(entry))) await drop(expired.jobId);
+		const live = current.filter((entry) => entry.jobId !== generation.jobId && isLive(entry));
+		const sharesBudget = (entry) => Boolean(entry.initial) === Boolean(generation.initial);
+		const entries = live.filter(sharesBudget);
+		entries.push({
+			...generation,
+			keptAt: now()
+		});
+		while (entries.length > 1 && (entries.length > maxCount || totalBytes(entries) > maxMb * MB)) await drop(entries.shift().jobId);
+		index = [...live.filter((entry) => !sharesBudget(entry)), ...entries];
+		await storage.writeItem(INDEX_KEY, JSON.stringify(index));
+	}
 	return {
 		keep,
 		drop,
 		/**
+		* Captures initial disk output, reusing a retained ID when its hashes and readable paths match.
+		* A temporary candidate is discarded on reuse, so reconnects do not consume retention slots.
+		*/
+		async keepInitial(files) {
+			const jobId = randomUUID();
+			const output = await keep({
+				jobId,
+				files,
+				maxSetMb: maxMb
+			});
+			const hashes = Object.entries(output.hashes);
+			const previous = (await load()).findLast((entry) => entry.initial && isLive(entry) && entry.output.paths.length === output.paths.length && Object.keys(entry.output.hashes).length === hashes.length && hashes.every(([path, hash]) => entry.output.hashes[path] === hash));
+			if (previous) {
+				await drop(jobId);
+				await add(previous);
+				return previous;
+			}
+			const generation = {
+				jobId,
+				output,
+				initial: true
+			};
+			await add(generation);
+			return generation;
+		},
+		/**
 		* Keeps the `InputNode` of `jobId` and returns its size in bytes, or 0 when it keeps none. A ref schema loses
 		* the copy of its target, which `input.schemas` holds: with it, a large spec outgrows what `JSON.stringify` can return.
 		*/
@@ -1564,30 +1596,19 @@ function createGenerationStore({ storage, maxCount, maxMb, ttlMs, now = Date.now
 			return stored === null ? void 0 : JSON.parse(stored);
 		},
 		get: async (jobId) => (await load()).find((generation) => generation.jobId === jobId && isLive(generation)),
-		async add(generation) {
-			const current = await load();
-			for (const expired of current.filter((entry) => !isLive(entry))) await drop(expired.jobId);
-			const entries = current.filter((entry) => entry.jobId !== generation.jobId && isLive(entry));
-			entries.push({
-				...generation,
-				keptAt: now()
-			});
-			while (entries.length > 1 && (entries.length > maxCount || totalBytes(entries) > maxMb * MB)) await drop(entries.shift().jobId);
-			index = entries;
-			await storage.writeItem(INDEX_KEY, JSON.stringify(entries));
-		},
+		add,
 		/**
 		* Reads the requested paths the set holds, skipping any it does not, one page of lines when `limit` is given.
 		*/
-		async read({ generation, source, paths, cursor = 0, limit }) {
-			const kept = new Set(generation[source]?.paths);
+		async read({ generation, paths, cursor = 0, limit }) {
+			const kept = new Set(generation.output.paths);
 			const files = {};
 			const pages = {};
 			await inParallel({
 				items: paths.filter((path) => kept.has(path)),
 				limit: READ_CONCURRENCY,
 				run: async (path) => {
-					const content = await storage.readItem(`${dirOf(generation.jobId)}${source}/${path}`);
+					const content = await storage.readItem(`${dirOf(generation.jobId)}output/${path}`);
 					if (content === null) return;
 					if (limit === void 0) {
 						files[path] = content;
@@ -1862,6 +1883,25 @@ function isValidPage({ cursor, limit }) {
 	if (cursor !== void 0 && (!Number.isSafeInteger(cursor) || cursor < 0)) return false;
 	return Number.isSafeInteger(limit) && limit >= 1 && limit <= 2e3;
 }
+/**
+* Maps generated paths into a temporary directory while keeping the project root for input resolution.
+*/
+function stagingStorage({ root, directory }) {
+	const storage = fsStorage();
+	const target = (key) => {
+		const relative = path.relative(root, path.resolve(root, key));
+		if (relative === ".." || relative.startsWith(`..${path.sep}`) || path.isAbsolute(relative)) throw new Error("Output path escapes the project root");
+		return path.join(directory, relative);
+	};
+	return {
+		name: "fs",
+		readItem: (key) => storage.readItem(target(key)),
+		writeItem: (key, value) => storage.writeItem(target(key), value),
+		removeItem: (key) => storage.removeItem(target(key)),
+		readKeys: (base) => storage.readKeys(base ? target(base) : directory),
+		empty: (base) => base ? storage.empty(target(base)) : Promise.resolve()
+	};
+}
 var GenerationRunTarget = class extends RpcTarget {
 	#run;
 	constructor(run) {
@@ -1886,6 +1926,7 @@ var Agent = class extends RpcTarget {
 	#session;
 	#limits = resolveGenerationLimits();
 	#store;
+	#sandboxCacheRoot = path.join(tmpdir(), `kubb-studio-${randomUUID()}`);
 	#diffs = /* @__PURE__ */ new Map();
 	constructor({ options, session }) {
 		super();
@@ -1907,13 +1948,19 @@ var Agent = class extends RpcTarget {
 	}
 	get #generations() {
 		this.#store ??= createGenerationStore({
-			storage: this.#sandbox ? memoryStorage() : cacheStorage({ root: this.#options.root }),
+			storage: cacheStorage({ root: this.#sandbox ? this.#sandboxCacheRoot : this.#options.root }),
 			maxCount: this.#limits.maxCount,
 			maxMb: this.#limits.maxMb,
 			ttlMs: this.#sandbox ? SANDBOX_GENERATION_TTL_MS : void 0
 		});
 		return this.#store;
 	}
+	async [Symbol.asyncDispose]() {
+		if (this.#sandbox) await rm(resolveCacheDir(this.#sandboxCacheRoot), {
+			recursive: true,
+			force: true
+		});
+	}
 	#warn({ message, permission }) {
 		return emit(this.#options.hooks, "studio:warn", {
 			message,
@@ -2025,7 +2072,12 @@ var Agent = class extends RpcTarget {
 			maxFiles: DISK_SNAPSHOT_MAX_FILES
 		});
 		if (!files) return void 0;
-		return { files: [...files.paths] };
+		const { jobId, output } = await this.#generations.keepInitial(files);
+		return {
+			jobId,
+			files: output.paths,
+			hashes: output.hashes
+		};
 	}
 	startGeneration(input) {
 		const stream = createGenerationStream(this.#options.hooks, input.jobId);
@@ -2044,7 +2096,9 @@ var Agent = class extends RpcTarget {
 			}
 		});
 	}
-	/** Runs one job and keeps its output, and its input with `allowRead`, for later reads. */
+	/**
+	* Keeps a job's output and permitted parsed input, then cleans up its temporary generation directories.
+	*/
 	async #runGeneration(input, controller) {
 		this.#assertConnected();
 		if (this.#session.closed) throw new Diagnostics.Error({
@@ -2060,11 +2114,14 @@ var Agent = class extends RpcTarget {
 			settled: settled.promise
 		};
 		let root = this.#options.root;
+		let outputRoot;
 		try {
 			if (this.#sandbox) root = await mkdtemp(path.join(tmpdir(), "kubb-job-"));
+			if (!this.#sandbox && !this.#permissions.allowWrite) outputRoot = await mkdtemp(path.join(tmpdir(), "kubb-output-"));
 			return await this.#generate({
 				input,
 				root,
+				outputRoot,
 				signal: controller.signal
 			});
 		} finally {
@@ -2075,12 +2132,18 @@ var Agent = class extends RpcTarget {
 				recursive: true,
 				force: true
 			})]).catch(() => {});
+			if (outputRoot) await rm(outputRoot, {
+				recursive: true,
+				force: true
+			});
 			this.#session.active = void 0;
 			settled.resolve();
 		}
 	}
-	/** Merges Studio's config over the disk config, refuses output paths outside the output folder, then generates in `root`. */
-	async #generate({ input, root, signal }) {
+	/**
+	* Merges Studio's config over the project config and confines generation to the configured output folder.
+	*/
+	async #generate({ input, root, outputRoot, signal }) {
 		const { jobId, config: patch } = input;
 		const studioInput = this.#sandbox ? patch?.input : void 0;
 		if (this.#sandbox && (typeof studioInput !== "string" || !studioInput.trim() || getInputKind(studioInput) !== "inline")) return this.#refuse({ message: AgentMessage.SANDBOX_INPUT_ONLY });
@@ -2111,37 +2174,28 @@ var Agent = class extends RpcTarget {
 		});
 		const activePlugins = plugins ?? config.plugins;
 		if (patch?.input && !this.#sandbox) await emit(this.#options.hooks, "kubb:warn", { message: "Ignored the spec from Studio: generating from a Studio spec is only available to a sandbox agent" });
-		const diskFiles = !this.#sandbox && this.#permissions.allowRead ? await listDisk({
-			root,
-			outputPath: config.output.path,
-			maxFiles: DISK_SNAPSHOT_MAX_FILES
-		}) : void 0;
-		const disk = diskFiles ? await this.#generations.keep({
-			jobId,
-			source: FileSource.DISK,
-			files: diskFiles,
-			maxSetMb: this.#limits.maxSnapshotMb
-		}) : void 0;
 		const files = await generate({
 			config: {
 				...config,
 				root,
 				input: studioInput ?? config.input,
-				storage: this.#permissions.allowWrite ? fsStorage() : memoryStorage(),
+				storage: outputRoot ? stagingStorage({
+					root,
+					directory: outputRoot
+				}) : fsStorage(),
 				plugins: activePlugins,
 				adapter,
 				parsers
 			},
 			hooks: this.#options.hooks,
 			signal,
-			allowExec: this.#permissions.allowExec
+			allowExec: this.#permissions.allowWrite && this.#permissions.allowExec
 		}).catch(async (error) => {
 			await this.#generations.drop(jobId);
 			throw error;
 		});
 		const output = await this.#generations.keep({
 			jobId,
-			source: FileSource.OUTPUT,
 			files,
 			maxSetMb: this.#limits.maxMb
 		});
@@ -2154,16 +2208,14 @@ var Agent = class extends RpcTarget {
 		await this.#generations.add({
 			jobId,
 			output,
-			disk,
 			inputBytes
 		});
-		await this.#logCommand("generate", `${activePlugins.length} plugin${activePlugins.length === 1 ? "" : "s"}, ${this.#permissions.allowWrite ? "written to disk" : "in memory"}${studioInput !== void 0 ? ", from a Studio spec" : ""}`);
+		await this.#logCommand("generate", `${activePlugins.length} plugin${activePlugins.length === 1 ? "" : "s"}, ${this.#permissions.allowWrite ? "written to disk" : "staged on disk"}${studioInput !== void 0 ? ", from a Studio spec" : ""}`);
 		return {
 			status: "success",
 			files: [...files.paths],
 			fileCount: files.paths.size,
-			hashes: output.hashes,
-			disk: disk ? { hashes: disk.hashes } : void 0
+			hashes: output.hashes
 		};
 	}
 	async saveConfig(input) {
@@ -2233,35 +2285,14 @@ var Agent = class extends RpcTarget {
 			message: AgentMessage.READ_NOT_ALLOWED,
 			permission: AgentPermission.READ
 		});
-		if (!Array.isArray(input.paths) || typeof input.jobId !== "string" || !input.jobId || !["generation", "currentDisk"].includes(input.jobType)) return this.#refuse({ message: AgentMessage.FILE_REQUEST_INVALID });
+		if (!Array.isArray(input.paths) || typeof input.jobId !== "string" || !input.jobId) return this.#refuse({ message: AgentMessage.FILE_REQUEST_INVALID });
 		const { paths } = input;
 		if (paths.length > 50) return this.#refuse({ message: AgentMessage.TOO_MANY_FILES });
 		if (!isValidPage(input)) return this.#refuse({ message: AgentMessage.INVALID_PAGE });
-		if (input.jobType === "currentDisk") {
-			if (this.#sandbox) return this.#refuse({ message: AgentMessage.SANDBOX_DISK_UNAVAILABLE });
-			const config = await this.#options.loadConfig();
-			const disk = await listDisk({
-				root: this.#options.root,
-				outputPath: config.output.path,
-				maxFiles: DISK_SNAPSHOT_MAX_FILES
-			});
-			if (!disk) return this.#refuse({ message: AgentMessage.GENERATION_GONE });
-			const result = await readDiskFiles({
-				files: disk,
-				paths,
-				cursor: input.cursor,
-				limit: input.limit
-			});
-			await this.#logCommand("readFiles", `read ${Object.keys(result.files).length}/${paths.length} requested file${paths.length === 1 ? "" : "s"}`);
-			return result;
-		}
 		const generation = await this.#generations.get(input.jobId);
 		if (!generation) return this.#refuse({ message: AgentMessage.GENERATION_GONE });
-		const source = input.source === FileSource.DISK ? FileSource.DISK : FileSource.OUTPUT;
-		if (!generation[source]) return this.#refuse({ message: AgentMessage.NO_DISK_SNAPSHOT });
 		const result = await this.#generations.read({
 			generation,
-			source,
 			paths,
 			cursor: input.cursor,
 			limit: input.limit
@@ -2286,15 +2317,11 @@ var Agent = class extends RpcTarget {
 		})) return this.#refuse({ message: AgentMessage.INVALID_PAGE });
 		const [generation, baseGeneration] = await Promise.all([this.#generations.get(jobId), this.#generations.get(base.jobId)]);
 		if (!generation || !baseGeneration) return this.#refuse({ message: AgentMessage.GENERATION_GONE });
-		const baseSource = base.source === FileSource.DISK ? FileSource.DISK : FileSource.OUTPUT;
-		if (!baseGeneration[baseSource]) return this.#refuse({ message: AgentMessage.NO_DISK_SNAPSHOT });
 		const [after, before] = await Promise.all([this.#generations.read({
 			generation,
-			source: FileSource.OUTPUT,
 			paths: [path]
 		}), this.#generations.read({
 			generation: baseGeneration,
-			source: baseSource,
 			paths: [path]
 		})]);
 		const afterContent = after.files[path];
@@ -2315,7 +2342,6 @@ var Agent = class extends RpcTarget {
 		const key = JSON.stringify([
 			jobId,
 			base.jobId,
-			baseSource,
 			path
 		]);
 		let diff = this.#diffs.get(key);
@@ -2372,14 +2398,15 @@ async function runSession({ options, openRpc, url, instanceId }) {
 		connected: Promise.withResolvers(),
 		closed: false
 	};
+	const agent = new Agent({
+		options,
+		session
+	});
 	const rpc = openRpc({
 		url,
 		token,
 		instanceId,
-		agent: new Agent({
-			options,
-			session
-		})
+		agent
 	});
 	signal?.addEventListener("abort", rpc.close, { once: true });
 	let timer;
@@ -2414,6 +2441,7 @@ async function runSession({ options, openRpc, url, instanceId }) {
 		await emit(hooks, "studio:warn", { message: "Canceled the running generation: the connection to Kubb Studio closed" });
 	}
 	await active?.settled;
+	await agent[Symbol.asyncDispose]();
 	return {
 		...close,
 		connected: session.info !== void 0
@@ -2721,10 +2749,9 @@ async function createSnapshotPackage({ files, packageInfo }) {
 	const root = await mkdtemp(join(tmpdir(), "kubb-snapshot-"));
 	const dist = join(root, "dist");
 	try {
-		await mkdir(dist);
+		await mkdir$1(dist);
 		await Promise.all([...sources].map(async ([path, { content }]) => {
-			await mkdir(dirname(join(root, path)), { recursive: true });
-			await writeFile(join(root, path), content);
+			await writeRaw(join(root, path), content);
 		}));
 		const entry = [...sources.keys()].filter((path) => /\.(?:[cm]?[jt]sx?)$/.test(path)).map((path) => join(root, path));
 		if (entry.length) {
@@ -2764,7 +2791,7 @@ async function createSnapshotPackage({ files, packageInfo }) {
 		const chunks = [...new Map([
 			["package.json", JSON.stringify(manifest, null, 2)],
 			...[...sources].map(([path, { content }]) => [path, content]),
-			...await Promise.all(built.map(async (key) => [`dist/${key}`, await readFile(join(dist, key), "utf8")]))
+			...await Promise.all(built.map(async (key) => [`dist/${key}`, await read(join(dist, key))]))
 		])].flatMap(([path, content]) => {
 			const bytes = Buffer.from(content);
 			return [
@@ -2795,7 +2822,10 @@ async function createSnapshot({ studioUrl = defaultStudioUrl, apiKey, config, ho
 		path: "/api/snapshots"
 	});
 	const generated = await generate({
-		config,
+		config: {
+			...config,
+			storage: fsStorage()
+		},
 		hooks,
 		signal,
 		allowExec: true