@kubb/studio 5.5.6 → 5.6.0

package/dist/index.js

@@ -1,22 +1,19 @@
-import { t as __name } from "./rolldown-runtime-CRm0XQPb.js";
-import { a as toPackageName, n as mergeAdapter, o as read, r as mergePlugins } from "./resolveConfig-DMIG_MH-.js";
+import "./rolldown-runtime-CRm0XQPb.js";
+import { a as resolvePeerDependencies, c as read, i as mergePlugins, r as mergeAdapter, s as toPackageName } from "./resolveConfig-DOUv_Tid.js";
 import { AGENT_INSTANCE_HEADER, AgentCloseCode, GENERATION_GONE_MESSAGE, MAX_PAGE_LINES, generationEventTypes } from "./protocol.js";
-import { createRequire } from "node:module";
+import { t as isLoopbackHost } from "./url-DhFfJpxp.js";
 import { createHash, hash, randomBytes, randomUUID } from "node:crypto";
 import { setTimeout as setTimeout$1 } from "node:timers/promises";
 import process$1 from "node:process";
-import { spawn } from "node:child_process";
-import { mkdtemp, readFile, rm } from "node:fs/promises";
 import path, { isAbsolute, relative, resolve, sep } from "node:path";
+import { mkdtemp, rm } from "node:fs/promises";
 import { FetchError, ofetch } from "ofetch";
-import { styleText } from "node:util";
+import { stripVTControlCharacters, styleText } from "node:util";
 import { createStorage } from "unstorage";
 import fsDriver from "unstorage/drivers/fs";
 import { tmpdir } from "node:os";
 import { Diagnostics, Hookable, cacheStorage, createKubb, fsStorage, memoryStorage, resolveCacheDir } from "@kubb/core";
 import { RpcTarget, newWebSocketRpcSession } from "capnweb";
-import WebSocket from "ws";
-import { x } from "tinyexec";
 //#region ../../internals/utils/src/errors.ts
 /**
 * Coerces an unknown thrown value to an `Error` instance.
@@ -47,44 +44,6 @@ function getErrorMessage(value) {
 //#endregion
 //#region ../../internals/utils/src/promise.ts
 /**
-* Wraps `factory` with a keyed cache backed by the provided store.
-*
-* Pass a `WeakMap` for object keys (results are GC-eligible when the key is
-* collected) or a `Map` for primitive keys. For multi-argument functions,
-* nest two `memoize` calls — the outer keyed by the first argument, the
-* inner (created once per outer miss) keyed by the second.
-*
-* Because the cache is owned by the caller, it can be shared, inspected, or
-* cleared independently of the memoized function.
-*
-* @example Single WeakMap key
-* ```ts
-* const cache = new WeakMap<SchemaNode, Set<string>>()
-* const getRefs = memoize(cache, (node) => collectRefs(node))
-* ```
-*
-* @example Single Map key (primitive)
-* ```ts
-* const cache = new Map<string, Resolver>()
-* const getResolver = memoize(cache, (name) => buildResolver(name))
-* ```
-*
-* @example Two-level (object + primitive)
-* ```ts
-* const outer = new WeakMap<Params[], Map<string, Params[]>>()
-* const fn = memoize(outer, (params) => memoize(new Map(), (key) => transform(params, key)))
-* fn(params)('camelcase')
-* ```
-*/
-function memoize(store, factory) {
-	return (key) => {
-		if (store.has(key)) return store.get(key);
-		const value = factory(key);
-		store.set(key, value);
-		return value;
-	};
-}
-/**
 * Runs `run` over every item with at most `limit` in flight. Workers share one iterator, so each
 * takes the next item the moment it frees up instead of waiting for a batch to drain.
 *
@@ -101,114 +60,6 @@ async function inParallel({ items, limit, run }) {
 	await Promise.all(Array.from({ length: Math.min(limit, items.length) }, () => worker()));
 }
 //#endregion
-//#region ../../internals/utils/src/tools.ts
-/**
-* CLI command descriptors for each supported code formatter.
-*/
-const formatters = {
-	prettier: {
-		command: "prettier",
-		args: (outputPath) => [
-			"--ignore-unknown",
-			"--write",
-			outputPath
-		],
-		errorMessage: "Prettier not found"
-	},
-	biome: {
-		command: "biome",
-		args: (outputPath) => [
-			"format",
-			"--write",
-			outputPath
-		],
-		errorMessage: "Biome not found"
-	},
-	oxfmt: {
-		command: "oxfmt",
-		args: (outputPath) => [outputPath],
-		errorMessage: "Oxfmt not found"
-	}
-};
-/**
-* CLI command descriptors for each supported linter.
-*/
-const linters = {
-	eslint: {
-		command: "eslint",
-		args: (outputPath) => [outputPath, "--fix"],
-		errorMessage: "Eslint not found"
-	},
-	biome: {
-		command: "biome",
-		args: (outputPath) => [
-			"lint",
-			"--fix",
-			outputPath
-		],
-		errorMessage: "Biome not found"
-	},
-	oxlint: {
-		command: "oxlint",
-		args: (outputPath) => [
-			"--fix",
-			"--no-ignore",
-			outputPath
-		],
-		errorMessage: "Oxlint not found"
-	}
-};
-/**
-* Preference order for `format: 'auto'`, most-preferred first. Spelled out rather than taken from
-* the table's key order, which is arbitrary and would silently change what `auto` picks.
-*/
-const FORMATTER_PREFERENCE = [
-	"oxfmt",
-	"biome",
-	"prettier"
-];
-/**
-* Preference order for `lint: 'auto'`, most-preferred first.
-*/
-const LINTER_PREFERENCE = [
-	"oxlint",
-	"biome",
-	"eslint"
-];
-/**
-* Whether `name` is on PATH and answers `--version` with a zero exit.
-*/
-function isToolAvailable(name) {
-	return new Promise((resolve) => {
-		const child = spawn(name, ["--version"], { stdio: "ignore" });
-		child.on("close", (code) => resolve(code === 0));
-		child.on("error", () => resolve(false));
-	});
-}
-/**
-* Returns the first installed executable from `candidates`, or `null` when none are found.
-*
-* Not memoized: a long-running host that probes repeatedly should cache the result itself, and a
-* `--watch` build should keep noticing a tool installed mid-session.
-*/
-async function detectTool$1(candidates) {
-	for (const candidate of candidates) if (await isToolAvailable(candidate)) return candidate;
-	return null;
-}
-__name(detectTool$1, "detectTool");
-/**
-* Tokenizes a shell command string, respecting single and double quotes.
-*
-* @example
-* ```ts
-* tokenize('git commit -m "initial commit"')
-* // → ['git', 'commit', '-m', 'initial commit']
-* ```
-*/
-function tokenize(command) {
-	return (command.match(/[^\s"']+|"([^"]*)"|'([^']*)'/g) ?? []).map((token) => token.replace(/^["']|["']$/g, ""));
-}
-//#endregion
 //#region ../../internals/utils/src/time.ts
 /**
 * Calculates elapsed time in milliseconds from a high-resolution `process.hrtime` start time.
@@ -542,8 +393,8 @@ const agentDefaults = {
 	heartbeatIntervalMs: 3e4,
 	/**
 	* Slowest heartbeat a host may ask for. Studio drops an agent from the active list once its
-	* stored ping is older than its liveness window, and it stores a ping at most once a minute, so
-	* a slower cadence would make a healthy agent look dead after a single missed ping.
+	* stored ping is older than its liveness window, and it persists a ping at most once an hour,
+	* so a slower cadence would make a healthy agent look dead after a single missed ping.
 	*/
 	maxHeartbeatIntervalMs: 6e4,
 	/** How long a heartbeat ping may take before the session is treated as dead. */
@@ -578,13 +429,20 @@ function resolveAgentCapacity(env = process.env) {
 }
 //#endregion
 //#region package.json
-var version = "5.5.6";
+var version = "5.6.0";
 //#endregion
 //#region src/operations/generations.ts
 const READ_CONCURRENCY = 50;
-const MB$1 = 1048576;
+const MB = 1048576;
 const INDEX_KEY = "studio/generations.json";
+/**
+* The path form {@link SourceFiles} keys on: relative to `root`, with forward slashes.
+*/
+function relativeStoragePath({ root, filePath }) {
+	return (isAbsolute(filePath) ? relative(resolve(root), filePath) : filePath).replaceAll("\\", "/");
+}
 const hashOf = (content) => createHash("sha1").update(content).digest("hex").slice(0, 16);
+const totalBytes = (entries) => entries.reduce((sum, { output, disk }) => sum + output.bytes + (disk?.bytes ?? 0), 0);
 /**
 * What the output directory holds on disk before a run. `undefined` when `outputPath` is not a real
 * subdirectory of `root` (listing the root would take in every source file) or holds more than `maxFiles`.
@@ -627,7 +485,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 }) {
-		const maxSetBytes = maxSetMb * MB$1;
+		const maxSetBytes = maxSetMb * MB;
 		const hashes = {};
 		let bytes = 0;
 		await inParallel({
@@ -665,7 +523,7 @@ function createGenerationStore({ storage, maxCount, maxMb, ttlMs, now = Date.now
 		get: async (jobId) => (await load()).find((generation) => generation.jobId === jobId && isLive(generation)),
 		latest: async () => (await load()).filter(isLive).at(-1),
 		/** Total bytes of every set the store holds, expired ones too until the next add drops them. */
-		bytes: async () => (await load()).reduce((sum, { output, disk }) => sum + output.bytes + (disk?.bytes ?? 0), 0),
+		bytes: async () => totalBytes(await load()),
 		async add(generation) {
 			const current = await load();
 			for (const expired of current.filter((entry) => !isLive(entry))) await drop(expired.jobId);
@@ -674,8 +532,7 @@ function createGenerationStore({ storage, maxCount, maxMb, ttlMs, now = Date.now
 				...generation,
 				keptAt: now()
 			});
-			const weight = () => entries.reduce((sum, { output, disk }) => sum + output.bytes + (disk?.bytes ?? 0), 0);
-			while (entries.length > 1 && (entries.length > maxCount || weight() > maxMb * MB$1)) await drop(entries.shift().jobId);
+			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));
 		},
@@ -714,40 +571,11 @@ function createGenerationStore({ storage, maxCount, maxMb, ttlMs, now = Date.now
 }
 //#endregion
 //#region src/operations/generationEvents.ts
-const require = createRequire(import.meta.url);
-function relativeStoragePath(root, filePath) {
-	return (isAbsolute(filePath) ? relative(resolve(root), filePath) : filePath).replaceAll("\\", "/");
-}
-async function resolvePeerDependencies(names) {
-	const uniqueNames = [...new Set(names.map(toPackageName))];
-	const peerDependencies = {};
-	const missingDependencies = [];
-	const versions = await Promise.all(uniqueNames.map(async (name) => {
-		try {
-			const path = require.resolve(`${name}/package.json`);
-			return JSON.parse(await readFile(path, "utf8")).version;
-		} catch {
-			return;
-		}
-	}));
-	for (const [index, name] of uniqueNames.entries()) {
-		const version = versions[index];
-		if (version) {
-			peerDependencies[name] = version;
-			continue;
-		}
-		missingDependencies.push(name);
-	}
-	return {
-		peerDependencies,
-		missingDependencies
-	};
-}
 const MAX_QUEUED_EVENTS = 1024;
 const RESERVED_EVENTS = 64;
 const isDiscardable = (event) => event.type === "kubb:files:processing:update" || event.type === "kubb:info" || event.type === "kubb:success";
 /** Forwards selected Kubb lifecycle events to a native Cap'n Web stream. */
-function createGenerationStream(hooks, jobId, options = {}) {
+function createGenerationStream(hooks, jobId) {
 	const unhooks = [];
 	let root = "";
 	let controller;
@@ -784,129 +612,92 @@ function createGenerationStream(hooks, jobId, options = {}) {
 		}
 		controller.enqueue(event);
 	}
-	on("kubb:plugin:start", (ctx) => {
-		emitEvent("kubb:plugin:start", [{ plugin: { name: ctx.plugin.name } }]);
-	});
-	on("kubb:plugin:end", (ctx) => {
-		emitEvent("kubb:plugin:end", [{
-			plugin: { name: ctx.plugin.name },
-			duration: ctx.duration,
-			success: ctx.success
-		}]);
-	});
-	on("kubb:build:start", ({ config, adapter }) => {
-		root = config.root;
-		emitEvent("kubb:build:start", [{
+	const projections = {
+		"kubb:plugin:start": ({ plugin }) => [{ plugin: { name: plugin.name } }],
+		"kubb:plugin:end": ({ plugin, duration, success }) => [{
+			plugin: { name: plugin.name },
+			duration,
+			success
+		}],
+		"kubb:build:start": ({ config, adapter }) => [{
 			config: { name: config.name },
 			adapter: { name: adapter.name }
-		}]);
-	});
-	on("kubb:build:end", ({ files, config, outputDir }) => {
-		emitEvent("kubb:build:end", [{
+		}],
+		"kubb:build:end": ({ files, config, outputDir }) => [{
 			files: files.map((file) => ({
-				path: relativeStoragePath(config.root, file.path),
+				path: relativeStoragePath({
+					root: config.root,
+					filePath: file.path
+				}),
 				name: file.name
 			})),
 			outputDir
-		}]);
-	});
-	on("kubb:files:processing:start", ({ files }) => {
-		emitEvent("kubb:files:processing:start", [{ total: files.length }]);
-	});
-	on("kubb:files:processing:update", ({ files }) => {
-		emitEvent("kubb:files:processing:update", [{ files: files.map(({ file, processed, total, percentage }) => ({
-			file: relativeStoragePath(root, file.path),
+		}],
+		"kubb:files:processing:start": ({ files }) => [{ total: files.length }],
+		"kubb:files:processing:update": ({ files }) => [{ files: files.map(({ file, processed, total, percentage }) => ({
+			file: relativeStoragePath({
+				root,
+				filePath: file.path
+			}),
 			processed,
 			total,
 			percentage
-		})) }]);
-	});
-	on("kubb:files:processing:end", ({ files }) => {
-		emitEvent("kubb:files:processing:end", [{ total: files.length }]);
-	});
-	for (const type of [
-		"kubb:info",
-		"kubb:success",
-		"kubb:warn"
-	]) on(type, ({ message, info }) => {
-		emitEvent(type, [{
-			message,
+		})) }],
+		"kubb:files:processing:end": ({ files }) => [{ total: files.length }],
+		"kubb:info": ({ message, info }) => [{
+			message: stripVTControlCharacters(message),
 			info
-		}]);
-	});
-	on("kubb:generation:start", ({ config }) => {
-		emitEvent("kubb:generation:start", [{
-			name: config.name,
-			plugins: config.plugins.length
-		}]);
-	});
-	on("kubb:generation:end", async ({ config, storage, diagnostics = [], status, hrStart, filesCreated }) => {
-		const { peerDependencies, missingDependencies } = await resolvePeerDependencies(config.plugins.map(({ name }) => name));
-		const keys = await storage.readKeys();
-		const paths = new Set(keys.map((key) => relativeStoragePath(config.root, key)));
-		options.onGenerationEnd?.({
-			output: {
-				storage,
-				root: config.root,
-				paths
-			},
-			peerDependencies,
-			missingDependencies
-		});
-		emitEvent("kubb:generation:end", []);
-		if (!hrStart) return;
-		emitEvent("kubb:generation:summary", [{
-			duration: Math.round(getElapsedMs(hrStart)),
-			fileCount: filesCreated ?? 0,
-			failedPlugins: Diagnostics.failedPlugins(diagnostics).length,
-			status: status ?? "success"
-		}]);
-	});
-	on("kubb:error", ({ error }) => {
-		emitEvent("kubb:error", [{
+		}],
+		"kubb:success": ({ message, info }) => [{
+			message: stripVTControlCharacters(message),
+			info
+		}],
+		"kubb:warn": ({ message, info }) => [{
+			message: stripVTControlCharacters(message),
+			info
+		}],
+		"kubb:error": ({ error }) => [{
 			message: error.message,
 			stack: error.stack
-		}]);
-	});
-	on("kubb:diagnostic", ({ diagnostic }) => {
-		const cause = "cause" in diagnostic ? diagnostic.cause : void 0;
-		emitEvent("kubb:diagnostic", [{
+		}],
+		"kubb:diagnostic": ({ diagnostic }) => [{
 			code: diagnostic.code,
 			message: diagnostic.message,
 			severity: diagnostic.severity,
 			location: "location" in diagnostic ? diagnostic.location : void 0,
 			help: "help" in diagnostic ? diagnostic.help : void 0,
 			plugin: "plugin" in diagnostic ? diagnostic.plugin : void 0,
-			stack: cause?.stack
-		}]);
-	});
-	for (const type of [
-		"kubb:lifecycle:start",
-		"kubb:lifecycle:end",
-		"kubb:format:start",
-		"kubb:format:end",
-		"kubb:lint:start",
-		"kubb:lint:end",
-		"kubb:hooks:start",
-		"kubb:hooks:end"
-	]) on(type, () => {
-		emitEvent(type, []);
-	});
-	on("kubb:hook:start", ({ id, command, args }) => {
-		emitEvent("kubb:hook:start", [{
+			stack: "cause" in diagnostic ? diagnostic.cause?.stack : void 0
+		}],
+		"kubb:generation:start": ({ config }) => [{
+			name: config.name,
+			plugins: config.plugins.length
+		}],
+		"kubb:generation:end": () => [],
+		"kubb:generation:summary": ({ duration, fileCount, failedPlugins, status }) => [{
+			duration,
+			fileCount,
+			failedPlugins,
+			status
+		}],
+		"kubb:lifecycle:start": () => [],
+		"kubb:lifecycle:end": () => [],
+		"kubb:format:start": () => [],
+		"kubb:format:end": () => [],
+		"kubb:lint:start": () => [],
+		"kubb:lint:end": () => [],
+		"kubb:hooks:start": () => [],
+		"kubb:hooks:end": () => [],
+		"kubb:hook:start": ({ id, command, args }) => [{
 			id,
 			command,
 			args: args ? [...args] : void 0
-		}]);
-	});
-	on("kubb:hook:line", ({ id, line }) => {
-		emitEvent("kubb:hook:line", [{
+		}],
+		"kubb:hook:line": ({ id, line }) => [{
 			id,
 			line
-		}]);
-	});
-	on("kubb:hook:end", ({ id, command, args, success, error }) => {
-		emitEvent("kubb:hook:end", [{
+		}],
+		"kubb:hook:end": ({ id, command, args, success, error }) => [{
 			id,
 			command,
 			args: args ? [...args] : void 0,
@@ -915,6 +706,22 @@ function createGenerationStream(hooks, jobId, options = {}) {
 				message: error.message,
 				stack: error.stack
 			} : void 0
+		}]
+	};
+	function forward(type) {
+		on(type, (...args) => emitEvent(type, projections[type](...args)));
+	}
+	on("kubb:build:start", ({ config }) => {
+		root = config.root;
+	});
+	for (const type of generationEventTypes) forward(type);
+	on("kubb:generation:end", ({ diagnostics = [], status, hrStart, filesCreated }) => {
+		if (!hrStart) return;
+		emitEvent("kubb:generation:summary", [{
+			duration: Math.round(getElapsedMs(hrStart)),
+			fileCount: filesCreated ?? 0,
+			failedPlugins: Diagnostics.failedPlugins(diagnostics).length,
+			status: status ?? "success"
 		}]);
 	});
 	/**
@@ -944,22 +751,8 @@ function createGenerationStream(hooks, jobId, options = {}) {
 	};
 }
 //#endregion
-//#region src/operations/websocket.ts
-const CONNECT_TIMEOUT_MS = 5e3;
-/**
-* Opens a Studio WebSocket connection and closes it when the initial handshake exceeds the configured timeout.
-*/
-function createWebsocket(url, options) {
-	const ws = new WebSocket(url, options);
-	const timer = setTimeout(() => {
-		if (ws.readyState === WebSocket.CONNECTING) ws.close(3008, "Connection timeout");
-	}, CONNECT_TIMEOUT_MS);
-	ws.once("open", () => clearTimeout(timer));
-	ws.once("close", () => clearTimeout(timer));
-	return ws;
-}
-//#endregion
 //#region src/operations/rpc.ts
+const CONNECT_TIMEOUT_MS = 5e3;
 /**
 * The only methods Studio may call on an agent. A `StudioSession` carries far more than
 * {@link AgentApi}, so it is wrapped rather than exposed: what Cap'n Web can reach is exactly what
@@ -991,6 +784,41 @@ var AgentRpcTarget = class extends RpcTarget {
 	}
 };
 /**
+* Opens a Studio WebSocket, closing it when the handshake exceeds {@link CONNECT_TIMEOUT_MS}. Node
+* fires no `close` event when the handshake itself fails, only `error`, so `closed` settles as 1006 there.
+*/
+function openSocket({ url, headers }) {
+	const socket = new WebSocket(url, { headers });
+	return {
+		socket,
+		closed: new Promise((resolve) => {
+			let opened = false;
+			const timer = setTimeout(() => {
+				if (socket.readyState === WebSocket.CONNECTING) socket.close(3008, "Connection timeout");
+			}, CONNECT_TIMEOUT_MS);
+			socket.addEventListener("open", () => {
+				opened = true;
+				clearTimeout(timer);
+			}, { once: true });
+			socket.addEventListener("close", (event) => {
+				clearTimeout(timer);
+				resolve({
+					code: event.code,
+					reason: event.reason
+				});
+			}, { once: true });
+			socket.addEventListener("error", () => {
+				if (opened) return;
+				clearTimeout(timer);
+				resolve({
+					code: 1006,
+					reason: ""
+				});
+			});
+		})
+	};
+}
+/**
 * Opens an authenticated Cap'n Web session to Studio over a WebSocket. Rejects an unencrypted URL
 * before opening the socket, so a bearer token never reaches a plaintext host.
 *
@@ -1002,15 +830,14 @@ var AgentRpcTarget = class extends RpcTarget {
 */
 const connectWebSocketRpc = async ({ url, token, instanceId, local }) => {
 	const { protocol, hostname, host } = new URL(url);
-	if (protocol !== "wss:" && !(protocol === "ws:" && (hostname === "localhost" || hostname === "127.0.0.1" || hostname === "[::1]"))) throw new Error(`Refusing unencrypted WebSocket to ${host}`);
-	const socket = createWebsocket(url, { headers: {
-		Authorization: `Bearer ${token}`,
-		[AGENT_INSTANCE_HEADER]: instanceId
-	} });
-	const closed = new Promise((resolve) => socket.once("close", (code, reason) => resolve({
-		code,
-		reason: reason.toString()
-	})));
+	if (protocol !== "wss:" && !(protocol === "ws:" && isLoopbackHost(hostname))) throw new Error(`Refusing unencrypted WebSocket to ${host}`);
+	const { socket, closed } = openSocket({
+		url,
+		headers: {
+			Authorization: `Bearer ${token}`,
+			[AGENT_INSTANCE_HEADER]: instanceId
+		}
+	});
 	const studio = newWebSocketRpcSession(socket, new AgentRpcTarget(local));
 	studio.onRpcBroken(() => socket.close());
 	return {
@@ -1020,256 +847,16 @@ const connectWebSocketRpc = async ({ url, token, instanceId, local }) => {
 	};
 };
 //#endregion
-//#region src/operations/hooks.ts
-/**
-* Register a `kubb:hook:start` listener that spawns the requested command via tinyexec,
-* streams each stdout line as a `kubb:hook:line` event, and calls `kubb:hook:end` with the result.
-* A failure travels on `kubb:hook:end` only: the caller waiting on it reports `kubb:error` once.
-* Streaming the output lets Kubb Studio render live hook progress over the WebSocket connection.
-*
-* Returns a remover, so a session that runs one generation after another on the same emitter does
-* not stack a listener per run.
-*/
-function setupHookListener(hooks, root, signal) {
-	return hooks.hook("kubb:hook:start", async (ctx) => {
-		const { id, command, args } = ctx;
-		if (!id) return;
-		const commandWithArgs = args?.length ? `${command} ${args.join(" ")}` : command;
-		try {
-			const proc = x(command, [...args ?? []], {
-				signal,
-				nodeOptions: {
-					cwd: root,
-					detached: true
-				}
-			});
-			for await (const line of proc) await hooks.callHook("kubb:hook:line", {
-				id,
-				line
-			});
-			const { exitCode } = await proc;
-			if (exitCode !== 0) {
-				const error = /* @__PURE__ */ new Error(`Hook execute failed: ${commandWithArgs}`);
-				await hooks.callHook("kubb:hook:end", {
-					id,
-					command,
-					args,
-					success: false,
-					error
-				});
-				return;
-			}
-			await hooks.callHook("kubb:hook:end", {
-				id,
-				command,
-				args,
-				success: true,
-				error: null
-			});
-		} catch (caughtError) {
-			const error = /* @__PURE__ */ new Error(`Hook execute failed: ${commandWithArgs}`);
-			error.cause = caughtError;
-			await hooks.callHook("kubb:hook:end", {
-				id,
-				command,
-				args,
-				success: false,
-				error
-			});
-		}
-	});
-}
-/**
-* Waits for the `kubb:hook:end` matching `hookId`. Register this before calling `kubb:hook:start`:
-* `callHook` awaits its listeners, and {@link setupHookListener} calls `kubb:hook:end` from inside
-* that same listener, so a handler added afterward would already have missed it.
-*/
-function waitForHookEnd(hooks, hookId) {
-	return new Promise((resolve, reject) => {
-		const handleHookEnd = (ctx) => {
-			if (ctx.id !== hookId) return;
-			hooks.removeHook("kubb:hook:end", handleHookEnd);
-			if (ctx.success) {
-				resolve();
-				return;
-			}
-			reject(ctx.error);
-		};
-		hooks.hook("kubb:hook:end", handleHookEnd);
-	});
-}
-//#endregion
-//#region src/operations/generate.ts
+//#region src/runtime/StudioSession.ts
 const DISK_SNAPSHOT_MAX_FILES = 1e4;
 /**
-* `isToolAvailable` spawns a process, and a long-lived connection generates repeatedly, so each
-* executable is probed once per process. The CLI deliberately does not memoize: a `--watch` build
-* should keep noticing a tool installed mid-session.
+* Folds error-severity diagnostics into one thrown error so logs name the failing plugin or pass.
 */
-const detectTool = memoize(/* @__PURE__ */ new Map(), detectTool$1);
-/**
-* The two post-build tool steps. Formatting and linting differ only in which tools they look for,
-* so they run through one loop rather than two near-identical blocks.
-*
-* `noun` and `verbing` are spelled out instead of built from `kind`. Concatenating `` `${kind}ter` ``
-* and `` `${kind}ting` `` works for `format`, but doubles the `t` in `lint`, giving "lintter" and
-* "lintting" instead of "linter" and "linting".
-*/
-const TOOL_STEPS = [{
-	kind: "format",
-	noun: "formatter",
-	verbing: "Formatting",
-	tools: formatters,
-	detect: FORMATTER_PREFERENCE
-}, {
-	kind: "lint",
-	noun: "linter",
-	verbing: "Linting",
-	tools: linters,
-	detect: LINTER_PREFERENCE
-}];
-/**
-* Absolute path of the directory the formatter and linter are pointed at.
-*/
-function outputPath(config) {
-	return path.isAbsolute(config.output.path) ? config.output.path : path.resolve(process$1.cwd(), config.root, config.output.path);
-}
-/**
-* Emits `kubb:hook:start` and waits for the matching `kubb:hook:end`. The host spawns the process:
-* this only describes what to run and when it finished.
-*
-* @throws whatever the command failed with, so callers can report it their own way.
-*/
-async function runHook({ hooks, id, command, args }) {
-	const hookId = hash("sha256", id);
-	const hookEnd = waitForHookEnd(hooks, hookId);
-	await hooks.callHook("kubb:hook:start", {
-		id: hookId,
-		command,
-		args: [...args]
-	});
-	await hookEnd;
-}
-function isProblemErrorDiagnostic(diagnostic) {
-	return (diagnostic.kind ?? "problem") === "problem" && diagnostic.severity === "error";
-}
-/**
-* Folds error-severity diagnostics into one thrown error so logs name the failing plugin.
-*/
-function formatGenerationFailure(diagnostics) {
-	const reasons = diagnostics.filter(isProblemErrorDiagnostic).map((diagnostic) => diagnostic.plugin ? `${diagnostic.plugin}: ${diagnostic.message}` : diagnostic.message);
+function generationFailure(diagnostics) {
+	const reasons = diagnostics.filter(Diagnostics.isProblem).filter((diagnostic) => diagnostic.severity === "error").map((diagnostic) => diagnostic.plugin ? `${diagnostic.plugin}: ${diagnostic.message}` : diagnostic.message);
 	if (!reasons.length) return /* @__PURE__ */ new Error("Generation failed");
 	return /* @__PURE__ */ new Error(`Generation failed: ${reasons.length} error${reasons.length === 1 ? "" : "s"}: ${reasons.join("; ")}`);
 }
-/**
-* Runs a full Kubb code-generation cycle for the given config.
-*
-* Emits lifecycle events on the provided `hooks` emitter so callers (e.g. the WebSocket stream)
-* can forward progress to connected clients. After a successful build, auto-formatting and
-* linting are applied when configured, followed by any user-defined `hooks.done` commands.
-*/
-async function generate({ config, hooks, signal }) {
-	signal?.throwIfAborted();
-	const hrStart = process$1.hrtime();
-	await hooks.callHook("kubb:generation:start", { config });
-	await hooks.callHook("kubb:info", { message: config.name ? `Setup generation ${config.name}` : "Setup generation" });
-	const kubb = createKubb(config, {
-		hooks,
-		signal
-	});
-	await kubb.setup();
-	await hooks.callHook("kubb:info", { message: config.name ? `Build generation ${config.name}` : "Build generation" });
-	const { files, diagnostics, storage } = await kubb.safeBuild();
-	signal?.throwIfAborted();
-	await hooks.callHook("kubb:info", { message: "Load summary" });
-	for (const diagnostic of diagnostics.filter(isProblemErrorDiagnostic)) await hooks.callHook("kubb:error", { error: new Error(diagnostic.plugin ? `${diagnostic.plugin}: ${diagnostic.message}` : diagnostic.message) });
-	const status = Diagnostics.hasError(diagnostics) ? "failed" : "success";
-	await hooks.callHook("kubb:generation:end", {
-		config,
-		storage: {
-			...storage,
-			readKeys: async () => [...new Set(files.map((file) => file.path))]
-		},
-		diagnostics,
-		status,
-		hrStart,
-		filesCreated: files.length
-	});
-	if (status === "failed") throw formatGenerationFailure(diagnostics);
-	await hooks.callHook("kubb:success", { message: "Generation successfully" });
-	for (const step of TOOL_STEPS) {
-		const setting = config.output[step.kind];
-		if (!setting) continue;
-		await hooks.callHook(`kubb:${step.kind}:start`);
-		const tool = setting === "auto" ? await detectTool(step.detect) : setting;
-		if (!tool) await hooks.callHook("kubb:warn", { message: `No ${step.noun} found (${step.detect.join(", ")}). Skipping ${step.verbing.toLowerCase()}.` });
-		if (tool && setting === "auto") await hooks.callHook("kubb:info", { message: `Auto-detected ${step.noun}: ${styleText("dim", tool)}` });
-		const command = tool ? step.tools[tool] : void 0;
-		if (command) try {
-			await runHook({
-				hooks,
-				id: [config.name, tool].filter(Boolean).join("-"),
-				command: command.command,
-				args: command.args(outputPath(config))
-			});
-			await hooks.callHook("kubb:success", { message: `${step.verbing} with ${tool} successfully` });
-		} catch (caughtError) {
-			await hooks.callHook("kubb:error", { error: new Error(command.errorMessage, { cause: caughtError }) });
-			signal?.throwIfAborted();
-		}
-		await hooks.callHook(`kubb:${step.kind}:end`);
-	}
-	if (config.output.postGenerate?.length) {
-		await hooks.callHook("kubb:hooks:start");
-		for (const entry of config.output.postGenerate) {
-			const line = typeof entry === "string" ? entry : entry.command;
-			const [cmd, ...args] = tokenize(line);
-			if (!cmd) continue;
-			try {
-				await runHook({
-					hooks,
-					id: line,
-					command: cmd,
-					args
-				});
-			} catch (error) {
-				await hooks.callHook("kubb:error", { error: toError(error) });
-				throw error;
-			}
-			await hooks.callHook("kubb:success", { message: `${line} successfully executed` });
-		}
-		await hooks.callHook("kubb:hooks:end");
-	}
-}
-async function runGenerationOperation({ config, hooks, signal, jobId, store, snapshotRoot, maxSnapshotMb }) {
-	const diskFiles = snapshotRoot ? await listDisk({
-		root: snapshotRoot,
-		outputPath: config.output.path,
-		maxFiles: DISK_SNAPSHOT_MAX_FILES
-	}) : void 0;
-	const disk = diskFiles ? await store.keep({
-		jobId,
-		source: "disk",
-		files: diskFiles,
-		maxSetMb: maxSnapshotMb
-	}) : void 0;
-	const removeHookListener = setupHookListener(hooks, config.root, signal);
-	try {
-		await generate({
-			config,
-			hooks,
-			signal
-		});
-	} catch (error) {
-		await store.drop(jobId);
-		throw error;
-	} finally {
-		removeHookListener();
-	}
-	return disk;
-}
-//#endregion
-//#region src/runtime/StudioSession.ts
 /** A sandbox shares one in-memory generation store across tenants, so old generations expire. */
 const SANDBOX_GENERATION_TTL_MS = 9e5;
 /**
@@ -1336,7 +923,6 @@ function applyStudioDefaults(options) {
 			allowRead: false,
 			...options.permissions
 		},
-		retryInterval: options.retryInterval ?? agentDefaults.retryIntervalMs,
 		heartbeatInterval: Math.min(options.heartbeatInterval ?? agentDefaults.heartbeatIntervalMs, agentDefaults.maxHeartbeatIntervalMs),
 		capacity: {
 			...resolveAgentCapacity(),
@@ -1350,10 +936,6 @@ function applyStudioDefaults(options) {
 * and with it each other's events, so the connection keeps this limit.
 */
 const RUNTIME_MAX_CONCURRENT = 1;
-const MB = 1048576;
-function rssMb() {
-	return process$1.memoryUsage().rss / MB;
-}
 /**
 * Reads what Studio meant by closing the connection. A code Studio did not send on purpose is an
 * ordinary drop, and the agent reconnects as it always has.
@@ -1401,12 +983,10 @@ var StudioSession = class {
 	*/
 	#registration;
 	#rpc;
-	#studioVersion;
 	#disposed = false;
 	#isGenerating = false;
 	#activeJob;
 	#heartbeatTimer;
-	#lastGeneration;
 	#store;
 	#limits = resolveGenerationLimits();
 	/**
@@ -1473,7 +1053,6 @@ var StudioSession = class {
 			});
 			signal?.throwIfAborted();
 			this.#registration = registration;
-			this.#studioVersion = registration.version;
 			const rpc = await (this.#options.connector ?? connectWebSocketRpc)({
 				url: registration.socketUrl,
 				token,
@@ -1490,7 +1069,7 @@ var StudioSession = class {
 			await this.#hooks.callHook("studio:connected", {
 				url: studioUrl,
 				versions: {
-					studio: this.#studioVersion,
+					studio: registration.version,
 					kubb: version,
 					agent: this.#options.version
 				},
@@ -1522,6 +1101,19 @@ var StudioSession = class {
 		await this.#warn(reason, permission);
 		throw new Error(message);
 	}
+	/**
+	* Brackets one Studio command with `studio:command:start` and `studio:command:end`. A command
+	* that declined its request reports no `info`, and only the start is heard.
+	*/
+	async #command({ command, run }) {
+		await this.#hooks.callHook("studio:command:start", { command });
+		const { value, info } = await run();
+		if (info !== void 0) await this.#hooks.callHook("studio:command:end", {
+			command,
+			info
+		});
+		return value;
+	}
 	#scheduleHeartbeat(interval) {
 		const rpc = this.#rpc;
 		if (!rpc) return;
@@ -1551,7 +1143,7 @@ var StudioSession = class {
 	async #load() {
 		return {
 			running: this.#isGenerating ? 1 : 0,
-			rssMb: Math.round(rssMb()),
+			rssMb: Math.round(process$1.memoryUsage().rss / 1048576),
 			storeBytes: await this.#generations.bytes(),
 			accepting: true
 		};
@@ -1565,7 +1157,7 @@ var StudioSession = class {
 	async #readConfigFileView(source) {
 		if (!this.#canEditConfig) return;
 		try {
-			const { readConfig } = await import("./configFile-BymXUi9P.js");
+			const { readConfig } = await import("./configFile-zhp5DQIe.js");
 			return readConfig(source ?? await read(this.#options.configFile));
 		} catch (error) {
 			await this.#warn(`Could not read ${this.#options.configFile}: ${getErrorMessage(error)}`);
@@ -1633,9 +1225,7 @@ var StudioSession = class {
 		}
 	}
 	startGeneration(data) {
-		const generationStream = createGenerationStream(this.#hooks, data.jobId, { onGenerationEnd: (result) => {
-			this.#lastGeneration = result;
-		} });
+		const generationStream = createGenerationStream(this.#hooks, data.jobId);
 		const controller = new AbortController();
 		const cancelRun = async () => {
 			controller.abort(/* @__PURE__ */ new Error("Generation canceled"));
@@ -1670,89 +1260,116 @@ var StudioSession = class {
 			jobId: data.jobId,
 			cancel: cancelRun
 		};
-		const command = "generate";
-		const { loadConfig, permissions } = this.#options;
 		let root = this.#options.root;
 		try {
 			if (this.#isSandbox) root = await createJobRoot();
-			await this.#hooks.callHook("studio:command:start", { command });
-			const config = await loadConfig();
-			const patch = data.config;
-			const plugins = await mergePlugins(config.plugins, patch?.plugins);
-			const adapter = await mergeAdapter(config.adapter, patch?.adapter);
-			const inputOverride = this.#isSandbox ? patch?.input ?? "" : void 0;
-			if (permissions.allowWrite && this.#isSandbox) await this.#warn("Running in a sandbox, so writing files is disabled");
-			if (patch?.input && !this.#isSandbox) await this.#warn("Ignored the spec from Studio: generating from a Studio spec is only available to a sandbox agent");
-			const resolvedPlugins = plugins ?? config.plugins;
-			this.#lastGeneration = void 0;
-			const disk = await runGenerationOperation({
-				config: {
-					...config,
+			return await this.#command({
+				command: "generate",
+				run: () => this.#generate({
+					data,
 					root,
-					input: inputOverride ?? config.input,
-					storage: this.#canWrite ? fsStorage() : memoryStorage(),
-					output: permissions.allowExec ? { ...config.output } : {
-						...config.output,
-						format: false,
-						lint: false,
-						postGenerate: []
-					},
-					plugins: resolvedPlugins,
-					adapter
-				},
-				hooks: this.#hooks,
-				signal: controller.signal,
-				jobId: data.jobId,
-				store: this.#generations,
-				snapshotRoot: this.#hasProjectOnDisk ? root : void 0,
-				maxSnapshotMb: this.#limits.maxSnapshotMb
-			});
-			await this.#hooks.callHook("studio:command:end", {
-				command,
-				info: `${resolvedPlugins.length} plugin${resolvedPlugins.length === 1 ? "" : "s"}, ${this.#canWrite ? "written to disk" : "in memory"}${inputOverride !== void 0 ? ", from a Studio spec" : ""}`
+					signal: controller.signal
+				})
 			});
-			const generation = this.#lastGeneration;
-			const output = generation ? await this.#generations.keep({
-				jobId: data.jobId,
-				source: "output",
-				files: generation.output,
-				maxSetMb: this.#limits.maxMb
-			}) : void 0;
-			if (generation && output) {
-				if (!output.paths.length && Object.keys(output.hashes).length) await this.#warn("Kept only the hashes of this generation: its output is too large to keep");
-				const { peerDependencies, missingDependencies } = generation;
-				await this.#generations.add({
-					jobId: data.jobId,
-					output,
-					disk,
-					peerDependencies,
-					missingDependencies
-				});
-			}
-			const files = [...generation?.output.paths ?? []];
-			return {
-				status: "success",
-				files,
-				fileCount: files.length,
-				hashes: output?.hashes ?? {},
-				disk: disk ? { hashes: disk.hashes } : void 0
-			};
 		} finally {
-			this.#lastGeneration = void 0;
 			if (root !== this.#options.root) await removeJobRoot(root);
 			this.#isGenerating = false;
 		}
 	}
-	async saveConfig(data) {
-		const command = "saveConfig";
-		await this.#hooks.callHook("studio:command:start", { command });
+	async #generate({ data, root, signal }) {
+		const { loadConfig, permissions } = this.#options;
+		const config = await loadConfig();
+		const patch = data.config;
+		const plugins = await mergePlugins(config.plugins, patch?.plugins);
+		const adapter = await mergeAdapter(config.adapter, patch?.adapter);
+		const inputOverride = this.#isSandbox ? patch?.input ?? "" : void 0;
+		if (permissions.allowWrite && this.#isSandbox) await this.#warn("Running in a sandbox, so writing files is disabled");
+		if (patch?.input && !this.#isSandbox) await this.#warn("Ignored the spec from Studio: generating from a Studio spec is only available to a sandbox agent");
+		const resolvedPlugins = plugins ?? config.plugins;
+		const storage = this.#canWrite ? fsStorage() : memoryStorage();
+		const diskFiles = this.#hasProjectOnDisk ? await listDisk({
+			root,
+			outputPath: config.output.path,
+			maxFiles: DISK_SNAPSHOT_MAX_FILES
+		}) : void 0;
+		const disk = diskFiles ? await this.#generations.keep({
+			jobId: data.jobId,
+			source: "disk",
+			files: diskFiles,
+			maxSetMb: this.#limits.maxSnapshotMb
+		}) : void 0;
+		const result = await createKubb({
+			...config,
+			root,
+			input: inputOverride ?? config.input,
+			storage,
+			output: permissions.allowExec ? { ...config.output } : {
+				...config.output,
+				format: false,
+				lint: false,
+				postGenerate: []
+			},
+			plugins: resolvedPlugins,
+			adapter
+		}, {
+			hooks: this.#hooks,
+			signal
+		}).generate().catch(async (error) => {
+			await this.#generations.drop(data.jobId);
+			throw error;
+		});
+		if (!result.success) {
+			await this.#generations.drop(data.jobId);
+			throw generationFailure(result.diagnostics);
+		}
+		const paths = new Set(result.files.map((file) => relativeStoragePath({
+			root,
+			filePath: file.path
+		})));
+		const output = await this.#generations.keep({
+			jobId: data.jobId,
+			source: "output",
+			files: {
+				storage,
+				root,
+				paths
+			},
+			maxSetMb: this.#limits.maxMb
+		});
+		if (!output.paths.length && Object.keys(output.hashes).length) await this.#warn("Kept only the hashes of this generation: its output is too large to keep");
+		const { peerDependencies, missingDependencies } = await resolvePeerDependencies(resolvedPlugins.map(({ name }) => name));
+		await this.#generations.add({
+			jobId: data.jobId,
+			output,
+			disk,
+			peerDependencies,
+			missingDependencies
+		});
+		return {
+			value: {
+				status: "success",
+				files: [...paths],
+				fileCount: paths.size,
+				hashes: output.hashes,
+				disk: disk ? { hashes: disk.hashes } : void 0
+			},
+			info: `${resolvedPlugins.length} plugin${resolvedPlugins.length === 1 ? "" : "s"}, ${this.#canWrite ? "written to disk" : "in memory"}${inputOverride !== void 0 ? ", from a Studio spec" : ""}`
+		};
+	}
+	saveConfig(data) {
+		return this.#command({
+			command: "saveConfig",
+			run: () => this.#saveConfig(data)
+		});
+	}
+	async #saveConfig(data) {
 		const { configPath, configFile } = this.#options;
 		if (!Array.isArray(data.edits)) {
 			await this.#warn("Ignored save: the message carried no edits");
-			return {
+			return { value: {
 				outcomes: [],
 				changed: false
-			};
+			} };
 		}
 		const edits = data.edits;
 		const refuse = (reason) => ({
@@ -1765,33 +1382,36 @@ var StudioSession = class {
 		});
 		if (!this.#canEditConfig) {
 			await this.#warn("Ignored save: editing kubb.config.ts was not granted");
-			return refuse("the agent was not granted permission to edit kubb.config.ts");
+			return { value: refuse("the agent was not granted permission to edit kubb.config.ts") };
 		}
-		if (this.#isGenerating) return refuse("a generation is in progress");
+		if (this.#isGenerating) return { value: refuse("a generation is in progress") };
 		try {
-			const { writeConfigEdits } = await import("./configFile-BymXUi9P.js");
+			const { writeConfigEdits } = await import("./configFile-zhp5DQIe.js");
 			const { source: patched, outcomes, changed } = await writeConfigEdits({
 				filePath: configFile,
 				edits
 			});
 			const applied = outcomes.filter((outcome) => outcome.applied).length;
-			await this.#hooks.callHook("studio:command:end", {
-				command,
-				info: `applied ${applied}/${outcomes.length} edits to ${configPath}`
-			});
 			return {
-				outcomes,
-				changed,
-				file: changed ? await this.#readConfigFileView(patched) : void 0
+				value: {
+					outcomes,
+					changed,
+					file: changed ? await this.#readConfigFileView(patched) : void 0
+				},
+				info: `applied ${applied}/${outcomes.length} edits to ${configPath}`
 			};
 		} catch (error) {
 			await this.#hooks.callHook("studio:error", { error: toError(error) });
-			return refuse(getErrorMessage(error));
+			return { value: refuse(getErrorMessage(error)) };
 		}
 	}
-	async publishSnapshot(data) {
-		const command = "snapshot";
-		await this.#hooks.callHook("studio:command:start", { command });
+	publishSnapshot(data) {
+		return this.#command({
+			command: "snapshot",
+			run: () => this.#publishSnapshot(data)
+		});
+	}
+	async #publishSnapshot(data) {
 		if (this.#isSandbox) return this.#refuse("Ignored snapshot: a sandbox agent has no project to build a package from", "A sandbox agent has no project to build a package from");
 		const { name, version, bundledDependencies, uploadPath } = data;
 		if (!name || !version || !uploadPath) return this.#refuse("Ignored snapshot: the message was missing required fields", "The request was missing required fields");
@@ -1801,7 +1421,7 @@ var StudioSession = class {
 		const missing = generation.missingDependencies.filter((dependency) => !bundled.has(dependency));
 		if (missing.length) return this.#refuse(`Ignored snapshot: missing dependencies: ${missing.join(", ")}`, `Missing dependencies: ${missing.join(", ")}`);
 		try {
-			const { createSnapshotPackage, uploadSnapshot } = await import("./snapshotPackage-I8bt8KTR.js");
+			const { createSnapshotPackage, uploadSnapshot } = await import("./snapshotPackage-BwZ8IJX-.js");
 			const { files } = await this.#generations.read({
 				generation,
 				source: "output",
@@ -1820,13 +1440,12 @@ var StudioSession = class {
 				token,
 				shutdown: signal
 			});
-			await this.#hooks.callHook("studio:command:end", {
-				command,
-				info: `packed ${Object.keys(files).length} file${Object.keys(files).length === 1 ? "" : "s"}`
-			});
 			return {
-				integrity,
-				peerDependencies: generation.peerDependencies
+				value: {
+					integrity,
+					peerDependencies: generation.peerDependencies
+				},
+				info: `packed ${Object.keys(files).length} file${Object.keys(files).length === 1 ? "" : "s"}`
 			};
 		} catch (error) {
 			await this.#hooks.callHook("studio:error", { error: toError(error) });
@@ -1837,9 +1456,13 @@ var StudioSession = class {
 	get #hasProjectOnDisk() {
 		return !this.#isSandbox && this.#canRead;
 	}
-	async readFiles(data) {
-		const command = "readFiles";
-		await this.#hooks.callHook("studio:command:start", { command });
+	readFiles(data) {
+		return this.#command({
+			command: "readFiles",
+			run: () => this.#readFiles(data)
+		});
+	}
+	async #readFiles(data) {
 		if (!this.#canRead) return this.#refuse("Ignored files: reading generated files was not granted", "The agent was not granted permission to read generated files", "allowRead");
 		if (!Array.isArray(data.paths)) return this.#refuse("Ignored files: the message carried no paths", "The request carried no paths");
 		const { paths } = data;
@@ -1857,11 +1480,10 @@ var StudioSession = class {
 			cursor: data.cursor,
 			limit: data.limit
 		});
-		await this.#hooks.callHook("studio:command:end", {
-			command,
+		return {
+			value: result,
 			info: `read ${Object.keys(result.files).length}/${paths.length} requested file${paths.length === 1 ? "" : "s"}`
-		});
-		return result;
+		};
 	}
 };
 //#endregion