@kubb/studio 5.5.3 → 5.5.4

package/dist/index.js

@@ -1,54 +1,22 @@
 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 { AGENT_INSTANCE_HEADER, AgentCloseCode, GENERATION_GONE_MESSAGE, MAX_PAGE_LINES, generationEventTypes } from "./protocol.js";
 import { createRequire } from "node:module";
 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 { glob, mkdir, mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
-import path, { isAbsolute, join, relative, resolve, sep } from "node:path";
+import { mkdtemp, readFile, rm } from "node:fs/promises";
+import path, { isAbsolute, relative, resolve, sep } from "node:path";
 import { FetchError, ofetch } from "ofetch";
-import { promisify, styleText } from "node:util";
+import { 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 { builders, detectCodeFormat, generateCode, parseModule } from "magicast";
-import { existsSync } from "node:fs";
-import { pathToFileURL } from "node:url";
-import { isPlainObject } from "remeda";
-import { gzip } from "node:zlib";
-import { build } from "tsdown";
 import { RpcTarget, newWebSocketRpcSession } from "capnweb";
 import WebSocket from "ws";
 import { x } from "tinyexec";
-//#region ../../internals/utils/src/casing.ts
-/**
-* Shared implementation for camelCase and PascalCase conversion.
-* Splits on common word boundaries (spaces, hyphens, underscores, dots, slashes, colons)
-* and capitalizes each word according to `pascal`.
-*
-* When `pascal` is `true` the first word is also capitalized (PascalCase), otherwise only subsequent words are.
-*/
-function toCamelOrPascal(text, pascal) {
-	return text.trim().replace(/([a-z\d])([A-Z])/g, "$1 $2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2").replace(/(\d)([a-z])/g, "$1 $2").split(/[\s\-_./\\:]+/).filter(Boolean).map((word, i) => {
-		if (word.length > 1 && word === word.toUpperCase()) return word;
-		return (i === 0 && !pascal ? word.charAt(0).toLowerCase() : word.charAt(0).toUpperCase()) + word.slice(1);
-	}).join("").replace(/[^a-zA-Z0-9]/g, "");
-}
-/**
-* Converts `text` to camelCase.
-*
-* @example Word boundaries
-* `camelCase('hello-world') // 'helloWorld'`
-*
-* @example With a prefix
-* `camelCase('tag', { prefix: 'create' }) // 'createTag'`
-*/
-function camelCase(text, { prefix = "", suffix = "" } = {}) {
-	return toCamelOrPascal(`${prefix} ${text} ${suffix}`, false);
-}
-//#endregion
 //#region ../../internals/utils/src/errors.ts
 /**
 * Coerces an unknown thrown value to an `Error` instance.
@@ -77,91 +45,6 @@ function getErrorMessage(value) {
 	return value instanceof Error ? value.message : String(value);
 }
 //#endregion
-//#region ../../internals/utils/src/runtime.ts
-/**
-* Detects the JavaScript runtime executing the current process and exposes its name and version.
-*
-* Prefer the shared {@link runtime} instance over constructing your own.
-*/
-var Runtime = class {
-	/**
-	* `true` when the current process is running under Bun.
-	*
-	* Detection keys off the global `Bun` object rather than `process.versions`,
-	* because Bun polyfills `process.versions.node` for Node compatibility and would
-	* otherwise look like Node.
-	*
-	* @example
-	* ```ts
-	* if (runtime.isBun) {
-	*   await Bun.write(path, data)
-	* }
-	* ```
-	*/
-	get isBun() {
-		return typeof Bun !== "undefined";
-	}
-	/**
-	* `true` when the current process is running under Deno.
-	*/
-	get isDeno() {
-		return typeof globalThis.Deno !== "undefined";
-	}
-	/**
-	* `true` when the current process is running under Node.
-	*
-	* Bun and Deno are excluded first so a polyfilled `process` does not register as Node.
-	*/
-	get isNode() {
-		return !this.isBun && !this.isDeno && typeof process !== "undefined" && process.versions?.node != null;
-	}
-	/**
-	* Name of the runtime executing the current process.
-	*
-	* @example
-	* ```ts
-	* runtime.name // 'bun' when run with `bun kubb`, 'node' otherwise
-	* ```
-	*/
-	get name() {
-		if (this.isBun) return "bun";
-		if (this.isDeno) return "deno";
-		return "node";
-	}
-	/**
-	* Version of the active runtime, or an empty string when it cannot be read.
-	*
-	* @example
-	* ```ts
-	* runtime.version // '1.3.11' under Bun, '22.22.2' under Node
-	* ```
-	*/
-	get version() {
-		if (this.isBun) return process.versions.bun ?? "";
-		if (this.isDeno) return globalThis.Deno?.version?.deno ?? "";
-		return process.versions?.node ?? "";
-	}
-};
-/**
-* Shared {@link Runtime} instance describing the JavaScript runtime executing the current process.
-*/
-const runtime = new Runtime();
-//#endregion
-//#region ../../internals/utils/src/fs.ts
-/**
-* Reads the file at `path` as a UTF-8 string.
-* Uses `Bun.file().text()` when running under Bun, `fs.readFile` otherwise.
-*
-* @example
-* ```ts
-* const source = await read('./src/Pet.ts')
-* ```
-*/
-async function read(path) {
-	if (runtime.isBun) return Bun.file(path).text();
-	return readFile(path, { encoding: "utf8" });
-}
-//#endregion
 //#region ../../internals/utils/src/promise.ts
 /**
 * Wraps `factory` with a keyed cache backed by the provided store.
@@ -695,944 +578,7 @@ function resolveAgentCapacity(env = process.env) {
 }
 //#endregion
 //#region package.json
-var version = "5.5.3";
-//#endregion
-//#region src/operations/resolveConfig.ts
-/**
-* Imports a package, falling back to how the user's project would resolve it.
-*
-* `import()` resolves from this file, so a linked or globally installed Studio (`pnpm link`,
-* `npm i -g`) only sees its own `node_modules` and misses the plugins installed next to the user's
-* config. The retry resolves from `process.cwd()` instead.
-*/
-async function importFromProject(packageName) {
-	try {
-		return await import(packageName);
-	} catch {
-		const resolved = createRequire(pathToFileURL(`${process.cwd()}/`)).resolve(packageName);
-		const esm = resolved.replace(/\.cjs$/, ".js");
-		return await import(pathToFileURL(esm !== resolved && existsSync(esm) ? esm : resolved).href);
-	}
-}
-/**
-* Strips the `@kubb/` scope from a plugin package name, matching the `name` convention Kubb
-* plugin factories use internally.
-*
-* @example
-* ```ts
-* toPluginName('@kubb/plugin-ts') // 'plugin-ts'
-* ```
-*/
-function toPluginName(packageName) {
-	return packageName.split("/").pop() ?? packageName;
-}
-/**
-* Adds the `@kubb/` scope a plugin's package carries but its `name` does not, the inverse of
-* {@link toPluginName}. A name outside the `plugin-` convention is left alone, so a third-party
-* plugin is not reported as one of Kubb's.
-*
-* @example
-* ```ts
-* toPackageName('plugin-ts')       // '@kubb/plugin-ts'
-* toPackageName('@acme/my-plugin') // '@acme/my-plugin'
-* ```
-*/
-function toPackageName(name) {
-	return name.startsWith("plugin-") ? `@kubb/${name}` : name;
-}
-/**
-* Derives the conventional named export for a `@kubb/*` plugin package from its package name.
-*
-* @example
-* ```ts
-* toExportName('@kubb/plugin-react-query') // 'pluginReactQuery'
-* toExportName('@kubb/plugin-ts')          // 'pluginTs'
-* ```
-*/
-function toExportName(packageName) {
-	return camelCase(toPluginName(packageName));
-}
-/**
-* A `@kubb/plugin-*` package specifier. Nothing else may reach `import()`: only Kubb's own
-* plugins are supported, so a payload naming anything else, a third-party package or a path, is
-* refused before it can execute.
-*/
-const KUBB_PLUGIN_SPECIFIER = /^@kubb\/plugin-[\w.-]+$/;
-/**
-* Whether `name` is a `@kubb/plugin-*` specifier. Exported so `configFile.ts` can refuse the same
-* shape before printing a Studio-supplied plugin name into the config file's source text.
-*/
-function isKubbPluginSpecifier(name) {
-	return KUBB_PLUGIN_SPECIFIER.test(name);
-}
-/**
-* Dynamically imports a `@kubb/plugin-*` package and returns its factory function.
-*
-* Packages must be pre-installed in the Docker image at build time via the `KUBB_PACKAGES`
-* build ARG, no runtime installation is possible in the distroless container.
-*
-* Resolution order: the camelCase named export the package name implies (e.g. `pluginTs`), then
-* the default export.
-*
-* @throws if the package cannot be imported or exports no callable factory.
-*/
-async function loadPluginFactory(packageName) {
-	if (!isKubbPluginSpecifier(packageName)) throw new Error(`Plugin "${packageName}" is not a @kubb/plugin-* package. Kubb Studio only supports Kubb's own plugins.`);
-	let mod;
-	try {
-		mod = await importFromProject(packageName);
-	} catch (cause) {
-		throw new Error(`Plugin "${packageName}" could not be loaded. Make sure it is installed: \`npm install ${packageName}\``, { cause });
-	}
-	const exportName = toExportName(packageName);
-	if (typeof mod[exportName] === "function") return mod[exportName];
-	if (typeof mod["default"] === "function") return mod["default"];
-	throw new Error(`Plugin "${packageName}" does not export a callable factory. Tried the named export "${exportName}" and "default".`);
-}
-/**
-* Resolves each plugin entry by dynamically importing the `@kubb/plugin-*` package and
-* calling its factory with the provided options.
-*
-* Packages must be pre-installed in the Docker image at build time, use the `KUBB_PACKAGES`
-* build ARG to control which ones are available at runtime.
-*
-* @example
-* ```ts
-* { name: '@kubb/plugin-react-query', options: { output: { path: './hooks' } } }
-* { name: '@kubb/plugin-ts', options: { output: { path: './types' } } }
-* ```
-*/
-async function resolvePlugins(plugins) {
-	return Promise.all(plugins.map(async ({ name, options }) => {
-		return (await loadPluginFactory(name))(options ?? {});
-	}));
-}
-/**
-* Whether `value` comes back unchanged from a JSON round trip. A function, a `RegExp` or another
-* class instance does not: the agent reports options to Studio as JSON, so what Studio sends back
-* for such a value is a lossy copy (`macros: [{ name }]` without its hooks, `pattern: {}`).
-*/
-function survivesJson(value) {
-	if (value === null || typeof value === "string" || typeof value === "boolean") return true;
-	if (typeof value === "number") return Number.isFinite(value);
-	if (Array.isArray(value)) return value.every(survivesJson);
-	if (isPlainObject(value)) return Object.values(value).every(survivesJson);
-	return false;
-}
-/**
-* Deep-merges Studio's options over the disk options, with Studio taking priority, except where the
-* disk value cannot survive JSON. Studio only ever saw a lossy copy of such a value, so the disk
-* value is kept rather than replaced by what Studio echoes back. Plain objects merge key by key, so
-* Studio can still change a literal that sits next to a function (e.g. `group.type` beside `group.name`).
-*
-* @example
-* ```ts
-* mergeOptions({ macros: [camelCaseMacro], syntaxType: 'type' }, { macros: [{ name: 'camelCase' }], syntaxType: 'interface' })
-* // { macros: [camelCaseMacro], syntaxType: 'interface' }
-* ```
-*/
-function mergeOptions(disk, studio) {
-	const merged = { ...disk };
-	for (const [key, value] of Object.entries(studio)) {
-		const current = disk[key];
-		if (isPlainObject(current) && isPlainObject(value)) {
-			merged[key] = mergeOptions(current, value);
-			continue;
-		}
-		if (current !== void 0 && !survivesJson(current)) continue;
-		merged[key] = value;
-	}
-	return merged;
-}
-/**
-* Merges studio plugin options with disk config plugins.
-* Studio takes priority: options from studio win over disk (except values only the disk config
-* can express, see {@link mergeOptions}), and a plugin Studio explicitly
-* disabled is dropped even when the disk config still lists it. Disk plugins without a studio
-* counterpart are kept as-is. Studio plugins not present on disk are appended.
-*
-* For plugins present in both configs, the plugin is re-instantiated with merged options
-* so that all internal closures correctly reference the merged values.
-*/
-async function mergePlugins(diskPlugins, studioPlugins) {
-	const disabledNames = new Set((studioPlugins ?? []).filter((entry) => entry.disabled).map((entry) => toPluginName(entry.name)));
-	const activeDiskPlugins = disabledNames.size ? diskPlugins?.filter((plugin) => !disabledNames.has(plugin.name)) : diskPlugins;
-	const activeStudioPlugins = studioPlugins?.filter((entry) => !entry.disabled);
-	if (!activeDiskPlugins && !activeStudioPlugins?.length) return void 0;
-	if (!activeStudioPlugins?.length) return activeDiskPlugins;
-	if (!activeDiskPlugins) return resolvePlugins(activeStudioPlugins);
-	const studioEntryByName = new Map(activeStudioPlugins.map((entry) => [toPluginName(entry.name), entry]));
-	const diskNames = new Set(activeDiskPlugins.map((plugin) => plugin.name));
-	const merged = await Promise.all(activeDiskPlugins.map(async (diskPlugin) => {
-		const studioEntry = studioEntryByName.get(diskPlugin.name);
-		if (!studioEntry) return diskPlugin;
-		const options = mergeOptions(diskPlugin.options ?? {}, studioEntry.options ?? {});
-		const [resolved] = await resolvePlugins([{
-			name: studioEntry.name,
-			options
-		}]);
-		return resolved ?? diskPlugin;
-	}));
-	const studioOnly = activeStudioPlugins.filter((entry) => !diskNames.has(toPluginName(entry.name)));
-	return [...merged, ...await resolvePlugins(studioOnly)];
-}
-/**
-* Merges Studio-provided adapter option overrides into the disk config's adapter.
-*
-* Adapter instances carry live functions (`parse`, `getImports`, ...) that can't survive
-* JSON serialization over the WebSocket, so `studioOptions` is treated as an options patch
-* rather than a replacement adapter. Re-invokes the same `@kubb/adapter-<name>` factory the
-* disk config used, with the merged options, so the resulting instance has fresh closures
-* over the merged values instead of a plain object missing `parse`.
-*/
-async function mergeAdapter(diskAdapter, studioOptions) {
-	if (!studioOptions || !diskAdapter) return diskAdapter;
-	const packageName = `@kubb/adapter-${diskAdapter.name}`;
-	const factory = (await importFromProject(packageName))[toExportName(packageName)];
-	if (typeof factory !== "function") return diskAdapter;
-	return factory(mergeOptions(diskAdapter.options ?? {}, studioOptions));
-}
-//#endregion
-//#region src/operations/configFile.ts
-/**
-* A valid JavaScript identifier, so an import name can only ever print as `import { name } from`,
-* never as source that breaks out of the import statement.
-*/
-const IDENTIFIER = /^[A-Za-z_$][\w$]*$/;
-/**
-* `key: value` as an object literal property, in the file's quote and key style.
-*
-* Uses magicast's literal builder for the key/value nodes, then wraps them as a Babel
-* `ObjectProperty`, the type the rest of this file reads.
-*/
-function literalProperty({ key, value }) {
-	const built = builders.literal({ [key]: value }).properties[0];
-	return {
-		type: "ObjectProperty",
-		key: built.key,
-		value: built.value,
-		computed: false,
-		shorthand: false
-	};
-}
-/**
-* Marks the comment block a `disable-plugin` leaves behind, so `enable-plugin` can find its way
-* back to the exact lines it commented out. Carries the block's line count, so `enable-plugin`
-* restores exactly those lines instead of scanning forward through whatever comments follow.
-*/
-const DISABLED_MARKER = "kubb:disabled";
-/**
-* The one line `disable-plugin` writes above the comment block it produces for `plugin`.
-*/
-function formatMarker(plugin, lineCount, indent = "") {
-	return `${indent}// ${DISABLED_MARKER} ${plugin} ${lineCount}`;
-}
-/**
-* The plugin and comment-block length a marker line names, when `line` is one.
-*/
-function parseMarker(line) {
-	const trimmed = line.trim();
-	if (!trimmed.startsWith(`// ${DISABLED_MARKER} `)) return;
-	const match = trimmed.slice(`// ${DISABLED_MARKER} `.length).match(/^(.+)\s+(\d+)$/);
-	return match ? {
-		plugin: match[1],
-		lineCount: Number(match[2])
-	} : void 0;
-}
-/**
-* Steps through a config's wrappers to the object literal underneath: a `satisfies`/`as`
-* assertion, a `() => ...` factory, or a factory whose block body returns the config.
-*/
-function unwrap(node) {
-	if (!node) return;
-	if (node.type === "TSAsExpression" || node.type === "TSSatisfiesExpression") return unwrap(node.expression);
-	if (node.type !== "ArrowFunctionExpression" && node.type !== "FunctionExpression") return node;
-	if (node.body.type !== "BlockStatement") return unwrap(node.body);
-	return unwrap(node.body.body.find((statement) => statement.type === "ReturnStatement")?.argument);
-}
-/**
-* Every config object in `export default defineConfig(...)`, or why the file is unmanaged.
-*
-* An array export gets one entry per element, matching {@link ConfigRef}'s numeric index.
-*
-* Walks the parsed AST rather than magicast's proxies, which throw on node types they cannot
-* cast, most of what an unmanaged config file is made of.
-*/
-function findConfigs(mod) {
-	const exported = unwrap((mod.$ast.type === "Program" ? mod.$ast.body : []).find((node) => node.type === "ExportDefaultDeclaration")?.declaration);
-	if (!exported) return { reason: "no default export found" };
-	if (exported.type !== "CallExpression" || exported.callee.type !== "Identifier" || exported.callee.name !== "defineConfig") return { reason: "default export is not a defineConfig(...) call" };
-	const argument = unwrap(exported.arguments[0]);
-	if (!argument) return { reason: "defineConfig(...) was called without a config" };
-	if (argument.type === "ArrayExpression") {
-		const configs = [];
-		for (const element of argument.elements) {
-			const entry = unwrap(element);
-			if (entry?.type !== "ObjectExpression") return { reason: "config is not an object literal" };
-			configs.push(entry);
-		}
-		return { configs };
-	}
-	if (argument.type !== "ObjectExpression") return { reason: "config is not an object literal" };
-	return { configs: [argument] };
-}
-/**
-* The config entry an edit names, defaulting to the first when it names none.
-*/
-function selectConfig(configs, ref) {
-	if (ref === void 0) return configs[0];
-	if (typeof ref === "number") return configs[ref];
-	return configs.find((config) => configName(config) === ref);
-}
-function configName(config) {
-	const name = property(config, "name");
-	return name?.type === "StringLiteral" ? name.value : void 0;
-}
-/**
-* The name of an object literal property, for the two key shapes a config uses: `key: value` and
-* `'key': value`. `undefined` for a computed key, which the patcher never touches.
-*/
-function propertyKey(entry) {
-	if (entry.key.type === "Identifier") return entry.key.name;
-	if (entry.key.type === "StringLiteral") return entry.key.value;
-}
-/**
-* The index of an object literal's own property named `key`, `-1` when it has none.
-*/
-function entryIndex({ node, key }) {
-	return node.properties.findIndex((entry) => entry.type === "ObjectProperty" && propertyKey(entry) === key);
-}
-/**
-* The value node of an object literal's own property.
-*/
-function property(node, key) {
-	const index = entryIndex({
-		node,
-		key
-	});
-	return index === -1 ? void 0 : node.properties[index].value;
-}
-/**
-* Writes `key: value` on an object literal, replacing the value when the property is already there.
-*
-* An existing property has its value swapped in place rather than being replaced whole, so recast
-* reprints only that value and leaves the object's own layout alone.
-*/
-function setProperty({ node, key, value }) {
-	const entry = literalProperty({
-		key,
-		value
-	});
-	const index = entryIndex({
-		node,
-		key
-	});
-	if (index === -1) {
-		node.properties.push(entry);
-		return;
-	}
-	node.properties[index].value = entry.value;
-}
-/**
-* Drops `key` from an object literal.
-*/
-function removeProperty({ node, key }) {
-	const index = entryIndex({
-		node,
-		key
-	});
-	if (index !== -1) node.properties.splice(index, 1);
-}
-/**
-* Reads a literal node's value: a primitive, or an object/array built only from primitives.
-* `undefined` for anything else, so a caller can use this both to read a value and to check
-* whether a node is a literal at all.
-*/
-function readLiteral(node) {
-	if (!node) return;
-	if (node.type === "StringLiteral" || node.type === "NumericLiteral" || node.type === "BooleanLiteral") return node.value;
-	if (node.type === "NullLiteral") return null;
-	if (node.type === "TemplateLiteral") return node.expressions.length === 0 ? node.quasis[0]?.value.cooked ?? "" : void 0;
-	if (node.type === "UnaryExpression") {
-		const value = readLiteral(node.argument);
-		if (typeof value !== "number") return;
-		if (node.operator === "-") return -value;
-		if (node.operator === "+") return value;
-		return;
-	}
-	if (node.type === "ArrayExpression") {
-		const values = node.elements.map((element) => element ? readLiteral(element) : void 0);
-		return values.every((value) => value !== void 0) ? values : void 0;
-	}
-	if (node.type === "ObjectExpression") {
-		const entries = {};
-		for (const entry of node.properties) {
-			if (entry.type !== "ObjectProperty") return;
-			const key = propertyKey(entry);
-			const value = readLiteral(entry.value);
-			if (key === void 0 || value === void 0) return;
-			entries[key] = value;
-		}
-		return entries;
-	}
-}
-/**
-* Maps a factory identifier in the file back to the module it was imported from.
-*/
-function importedFrom(mod) {
-	return new Map(mod.imports.$items.map((item) => [item.local, item.from]));
-}
-/**
-* Every `pluginX(...)` element of a config's plugins array that resolves to an import.
-*/
-function pluginCalls(mod, config) {
-	const plugins = property(config, "plugins");
-	if (plugins?.type !== "ArrayExpression") return [];
-	const imports = importedFrom(mod);
-	return plugins.elements.flatMap((element) => {
-		if (element?.type !== "CallExpression" || element.callee.type !== "Identifier") return [];
-		const packageName = imports.get(element.callee.name);
-		return packageName ? [{
-			importName: element.callee.name,
-			packageName,
-			call: element
-		}] : [];
-	});
-}
-/**
-* Plugins a previous `disable-plugin` commented out of this config, keyed by package name.
-*
-* Read from the marker lines rather than the AST, since a commented-out call is no longer a node.
-*/
-function disabledMarkers(source) {
-	return source.split("\n").flatMap((line, index) => {
-		const marker = parseMarker(line);
-		return marker ? [{
-			packageName: marker.plugin,
-			line: index + 1
-		}] : [];
-	});
-}
-/**
-* Reads which plugins the file declares and which of their options Studio may write.
-*
-* @example
-* ```ts
-* const view = readConfig(await readFile('kubb.config.ts', 'utf8'))
-* if (view.managed) {
-*   view.configs.forEach((config) => console.log(config.name, config.plugins.length))
-* }
-* ```
-*/
-function readConfig(source) {
-	let mod;
-	try {
-		mod = parseModule(source);
-	} catch {
-		return {
-			managed: false,
-			reason: "the config file could not be parsed"
-		};
-	}
-	const found = findConfigs(mod);
-	if ("reason" in found) return {
-		managed: false,
-		reason: found.reason
-	};
-	const importNames = new Map([...importedFrom(mod)].map(([local, from]) => [from, local]));
-	const disabled = disabledMarkers(source);
-	return {
-		managed: true,
-		configs: found.configs.map((config) => {
-			const plugins = pluginCalls(mod, config).map(({ importName, packageName, call }) => {
-				const entries = {};
-				const options = call.arguments[0];
-				if (options?.type === "ObjectExpression") for (const entry of options.properties) {
-					if (entry.type !== "ObjectProperty") continue;
-					const key = propertyKey(entry);
-					if (key === void 0) continue;
-					const value = readLiteral(entry.value);
-					entries[key] = value === void 0 ? { literal: false } : {
-						literal: true,
-						value
-					};
-				}
-				return {
-					importName,
-					packageName,
-					options: entries
-				};
-			});
-			const start = config.loc?.start.line ?? 0;
-			const end = config.loc?.end.line ?? Number.POSITIVE_INFINITY;
-			for (const { packageName } of disabled.filter((entry) => entry.line >= start && entry.line <= end)) plugins.push({
-				importName: importNames.get(packageName) ?? toExportName(packageName),
-				packageName,
-				options: {},
-				disabled: true
-			});
-			return {
-				name: configName(config),
-				plugins
-			};
-		})
-	};
-}
-/**
-* Whether a value can be written into a config file as a literal.
-*
-* This is the trust boundary for edits that arrive over the agent WebSocket: a function, `undefined`,
-* or a non-finite number is refused rather than printed into the user's source.
-*/
-function isOptionValue(value) {
-	if (value === null) return true;
-	if (typeof value === "string" || typeof value === "boolean") return true;
-	if (typeof value === "number") return Number.isFinite(value);
-	if (Array.isArray(value)) return value.every(isOptionValue);
-	if (typeof value === "object") return Object.values(value).every(isOptionValue);
-	return false;
-}
-/**
-* The options object of a plugin call, when it was called with one.
-*/
-function getOptions(call) {
-	const options = call.arguments[0];
-	return options?.type === "ObjectExpression" ? options : void 0;
-}
-/**
-* The options object of a plugin call, creating an empty one when the plugin was called bare.
-*/
-function ensureOptions(call) {
-	if (call.arguments.length === 0) call.arguments.push({
-		type: "ObjectExpression",
-		properties: []
-	});
-	return getOptions(call);
-}
-/**
-* Walks `path` down to the object holding its last key, descending only through object literals.
-*/
-function optionParent(options, path) {
-	let object = options;
-	for (const [index, key] of path.entries()) {
-		if (index === path.length - 1) return {
-			object,
-			key
-		};
-		if (property(object, key) === void 0) setProperty({
-			node: object,
-			key,
-			value: {}
-		});
-		const next = property(object, key);
-		if (next?.type !== "ObjectExpression") return { reason: `${key} is not an object, so ${path.join(".")} cannot be reached` };
-		object = next;
-	}
-	return { reason: "no option path given" };
-}
-/**
-* Writes `value` at `path` inside a plugin call's options, creating the options object and any
-* intermediate object along the path as needed. Refuses when the current value at `path` is
-* something other than a literal, so an option customized in code is never overwritten.
-*/
-function applySet(call, path, value) {
-	if (!isOptionValue(value)) return "the value is not a literal that can be written to a config file";
-	const options = ensureOptions(call);
-	if (!options) return "the plugin was not called with an object literal";
-	const target = optionParent(options, path);
-	if ("reason" in target) return target.reason;
-	const current = property(target.object, target.key);
-	if (current !== void 0 && readLiteral(current) === void 0) return `${path.join(".")} is customized in code`;
-	setProperty({
-		node: target.object,
-		key: target.key,
-		value
-	});
-}
-/**
-* Deletes the property at `path` inside a plugin call's options, falling the plugin back to its
-* default for that option. Refuses when the value at `path` is not a literal, for the same reason
-* `applySet` does.
-*/
-function applyRemove(call, path) {
-	const options = getOptions(call);
-	if (!options) return "the plugin has no options to remove";
-	const target = optionParent(options, path);
-	if ("reason" in target) return target.reason;
-	const current = property(target.object, target.key);
-	if (current === void 0) return `${path.join(".")} is not set`;
-	if (readLiteral(current) === void 0) return `${path.join(".")} is customized in code`;
-	removeProperty({
-		node: target.object,
-		key: target.key
-	});
-}
-/**
-* Adds a `pluginX(...)` call to a config's plugins array. Replaying the same add is a no-op, while
-* an import name collision with an unrelated package remains an error.
-*/
-function applyAddPlugin(mod, config, edit) {
-	if (!isKubbPluginSpecifier(edit.plugin)) return { reason: `"${edit.plugin}" is not a @kubb/plugin-* package` };
-	const importName = edit.importName ?? toExportName(edit.plugin);
-	if (!IDENTIFIER.test(importName)) return { reason: `"${importName}" is not a valid import name` };
-	if (pluginCalls(mod, config).some((plugin) => plugin.packageName === edit.plugin)) return { noop: true };
-	const taken = importedFrom(mod).get(importName);
-	if (taken && taken !== edit.plugin) return { reason: `${importName} is already imported from ${taken}` };
-	const options = edit.options ?? {};
-	if (!isOptionValue(options)) return { reason: "the options are not literals that can be written to a config file" };
-	const plugins = property(config, "plugins");
-	if (plugins?.type !== "ArrayExpression") return { reason: "plugins is not an array literal" };
-	const call = Object.keys(options).length ? builders.functionCall(importName, options) : builders.functionCall(importName);
-	plugins.elements.push(call.$ast);
-	return taken ? {} : { addImport: {
-		importName,
-		moduleSpecifier: edit.plugin
-	} };
-}
-/**
-* Comments out a plugin call in place, keeping its options on disk so `enable-plugin` can restore
-* them exactly. Operates on `source` text rather than the AST: a commented-out call is no longer a
-* node magicast can address, and the surrounding array must not reflow when its element count
-* never actually changes.
-*/
-function disablePlugin(source, mod, config, plugin) {
-	const target = pluginCalls(mod, config).find((entry) => entry.packageName === plugin);
-	if (!target) return { reason: `${plugin} is not in the plugins array` };
-	const loc = target.call.loc;
-	if (!loc?.start || !loc.end) return { reason: `${plugin} has no source location to comment out` };
-	const lines = source.split("\n");
-	const from = loc.start.line - 1;
-	const to = loc.end.line - 1;
-	const firstLine = lines[from] ?? "";
-	const lastLine = lines[to] ?? "";
-	if (firstLine.slice(0, loc.start.column).trim() !== "" || !/^,?\s*$/.test(lastLine.slice(loc.end.column))) return { reason: `${plugin} shares a line with other code, so it cannot be commented out safely` };
-	const indent = firstLine.match(/^\s*/)?.[0] ?? "";
-	const commented = lines.slice(from, to + 1).map((line) => line.trim() ? `${indent}// ${line.slice(indent.length)}` : indent ? `${indent}//` : "//");
-	lines.splice(from, to - from + 1, formatMarker(plugin, commented.length, indent), ...commented);
-	return { source: lines.join("\n") };
-}
-/**
-* Uncomments the block a previous `disable-plugin` left behind for `plugin`.
-*/
-function enablePlugin(source, plugin) {
-	const lines = source.split("\n");
-	for (const [index, line] of lines.entries()) {
-		const marker = parseMarker(line);
-		if (marker?.plugin !== plugin) continue;
-		const end = index + 1 + marker.lineCount;
-		const restored = lines.slice(index + 1, end).map((commented) => commented.replace(/^(\s*)\/\/ ?/, "$1"));
-		lines.splice(index, end - index, ...restored);
-		return { source: lines.join("\n") };
-	}
-	return { reason: `${plugin} is not disabled` };
-}
-/**
-* Re-parses `source` and resolves the config entry an edit targets. Every edit re-parses rather
-* than sharing one module across the batch, since the disable/enable edits rewrite `source` as
-* text and would otherwise leave the others working from a stale tree.
-*/
-function parseTarget(source, ref) {
-	let mod;
-	try {
-		mod = parseModule(source);
-	} catch {
-		return { reason: "the config file could not be parsed" };
-	}
-	const found = findConfigs(mod);
-	if ("reason" in found) return { reason: found.reason };
-	const config = selectConfig(found.configs, ref);
-	if (!config) return { reason: `no config entry found for ${JSON.stringify(ref)}` };
-	return {
-		mod,
-		config
-	};
-}
-/**
-* Applies edits to a `kubb.config.ts` in place. Every node the edits do not touch keeps its
-* original text, so comments, formatting, and hand-written code around the config survive.
-*
-* Edits are independent: one that cannot be applied is reported in `outcomes` and the rest still run.
-*
-* @example
-* ```ts
-* const { source, outcomes } = applyConfigEdits(current, [
-*   { operation: 'set', plugin: '@kubb/plugin-ts', path: ['enum', 'type'], value: 'enum' },
-* ])
-* ```
-*
-* @note recast always reprints a semicolon on a reprinted statement, so editing a block-body
-* `defineConfig` in a semicolon-free file adds one to the `return` line. This is a known gap.
-* Strip it when `detectCodeFormat` reports `useSemi: false`, if it turns out to matter in practice.
-*/
-function applyConfigEdits(source, edits) {
-	let current = source;
-	const format = detectCodeFormat(source);
-	const endsWithNewline = source.endsWith("\n");
-	const outcomes = edits.map((edit) => {
-		const target = parseTarget(current, edit.config);
-		if ("reason" in target) return {
-			edit,
-			applied: false,
-			reason: target.reason
-		};
-		const { mod, config } = target;
-		if (edit.operation === "disable-plugin" || edit.operation === "enable-plugin") {
-			const result = edit.operation === "disable-plugin" ? disablePlugin(current, mod, config, edit.plugin) : enablePlugin(current, edit.plugin);
-			if ("reason" in result) return {
-				edit,
-				applied: false,
-				reason: result.reason
-			};
-			current = result.source;
-			return {
-				edit,
-				applied: true
-			};
-		}
-		if (edit.operation === "add-plugin") {
-			const result = applyAddPlugin(mod, config, edit);
-			if ("reason" in result) return {
-				edit,
-				applied: false,
-				reason: result.reason
-			};
-			if ("noop" in result) return {
-				edit,
-				applied: true
-			};
-			const afterLine = lastImportEndLine(mod);
-			let next = generateCode(mod, { format }).code;
-			if (result.addImport) next = insertImportLine({
-				source: next,
-				afterLine,
-				...result.addImport
-			});
-			current = withTrailingNewline(next, endsWithNewline);
-			return {
-				edit,
-				applied: true
-			};
-		}
-		const pluginCall = pluginCalls(mod, config).find((plugin) => plugin.packageName === edit.plugin);
-		if (!pluginCall) return {
-			edit,
-			applied: false,
-			reason: `${edit.plugin} is not in the plugins array`
-		};
-		const reason = edit.operation === "set" ? applySet(pluginCall.call, edit.path, edit.value) : applyRemove(pluginCall.call, edit.path);
-		if (!reason) current = withTrailingNewline(generateCode(mod, { format }).code, endsWithNewline);
-		return {
-			edit,
-			applied: !reason,
-			reason
-		};
-	});
-	return {
-		source: current,
-		outcomes,
-		changed: current !== source
-	};
-}
-async function writeConfigEdits({ filePath, edits }) {
-	const result = applyConfigEdits(await read(filePath), edits);
-	if (result.changed) await writeFile(filePath, result.source, "utf-8");
-	return result;
-}
-/**
-* The 1-based line where the file's last import declaration ends, or `0` when it has none. Read
-* off the parsed module, so a multi-line `import {\n  x,\n} from '...'` reports its closing line
-* rather than the `import` keyword.
-*/
-function lastImportEndLine(mod) {
-	return (mod.$ast.type === "Program" ? mod.$ast.body : []).filter((node) => node.type === "ImportDeclaration").at(-1)?.loc?.end.line ?? 0;
-}
-/**
-* Writes an import after the last one already in the file, matching its quote style and whether it
-* ends in a semicolon. `afterLine` is where that last import ends, `0` for a file with none.
-*
-* Written as plain text rather than through magicast's import builder, which prints a brand-new
-* import declaration with its own default spacing and a semicolon regardless of `format`, since
-* that formatting only governs nodes recast can diff against the original source.
-*/
-function insertImportLine({ source, importName, moduleSpecifier, afterLine }) {
-	const lines = source.split("\n");
-	const lastImportLine = afterLine > 0 ? lines[afterLine - 1] : void 0;
-	const quote = lastImportLine?.includes(`"`) ? `"` : `'`;
-	const line = `import { ${importName} } from ${quote}${moduleSpecifier}${quote}${lastImportLine?.trimEnd().endsWith(";") ? ";" : ""}`;
-	lines.splice(afterLine, 0, ...afterLine > 0 ? [line] : [line, ""]);
-	return lines.join("\n");
-}
-/**
-* `generateCode` always drops the file's trailing newline. Restore it when the input had one.
-*/
-function withTrailingNewline(code, hadTrailingNewline) {
-	if (!hadTrailingNewline || code.endsWith("\n")) return code;
-	return `${code}\n`;
-}
-//#endregion
-//#region src/operations/snapshotPackage.ts
-const gzipAsync = promisify(gzip);
-const UPLOAD_TIMEOUT_MS = 12e4;
-/**
-* Maps a generated file's path to its place inside the tarball, stripping everything before a
-* `src`/`dist` segment and any `..`/empty path segment so a crafted file name cannot escape the
-* `package/` root.
-*/
-function packagePath(filePath) {
-	const normalized = filePath.replaceAll("\\", "/");
-	return `package/${(normalized.match(/\/(?:src|dist)\/.*$/)?.[0].slice(1) ?? normalized.replace(/^\/+/, "")).split("/").filter((part) => part && part !== "." && part !== "..").join("/")}`;
-}
-/**
-* Splits a tarball entry path into the legacy 100-byte `name` field and, when the path does not
-* fit, the 155-byte USTAR `prefix` field that extends it. Throws rather than silently truncating
-* a path the format cannot address (max 256 bytes: 100 name + 1 separator + 155 prefix).
-*/
-function splitEntryPath(path) {
-	if (Buffer.byteLength(path, "utf8") <= 100) return {
-		name: path,
-		prefix: ""
-	};
-	for (let i = path.length - 1; i >= 0; i--) {
-		if (path[i] !== "/") continue;
-		const prefix = path.slice(0, i);
-		const name = path.slice(i + 1);
-		if (Buffer.byteLength(prefix, "utf8") <= 155 && Buffer.byteLength(name, "utf8") <= 100) return {
-			name,
-			prefix
-		};
-	}
-	throw new Error(`Snapshot path is too long for a tar entry: ${path}`);
-}
-function header(path, size) {
-	const { name, prefix } = splitEntryPath(path);
-	const value = Buffer.alloc(512);
-	value.write(name, 0, "utf8");
-	value.write("0000644\0", 100, "ascii");
-	value.write("0000000\0", 108, "ascii");
-	value.write("0000000\0", 116, "ascii");
-	value.write(`${size.toString(8).padStart(11, "0")}\0`, 124, "ascii");
-	value.write(`${Math.floor(Date.now() / 1e3).toString(8).padStart(11, "0")}\0`, 136, "ascii");
-	value.fill(32, 148, 156);
-	value.write("0", 156, "ascii");
-	value.write("ustar\0", 257, "ascii");
-	value.write("00", 263, "ascii");
-	value.write("0000000\0", 265, "ascii");
-	value.write("0000000\0", 297, "ascii");
-	value.write(prefix, 345, "utf8");
-	const checksum = [...value].reduce((sum, byte) => sum + byte, 0);
-	value.write(`${checksum.toString(8).padStart(6, "0")}\0 `, 148, "ascii");
-	return value;
-}
-/**
-* Packs a generation's files into a gzipped, npm-installable tarball: a `package/` root with the
-* generated sources, a `tsdown`-built `dist/` (esm + cjs), and a `package.json` manifest.
-*/
-async function createSnapshotPackage(files, packageInfo) {
-	const root = await mkdtemp(join(tmpdir(), "kubb-snapshot-"));
-	const dist = join(root, "dist");
-	const resolvedPaths = Object.entries(files).map(([name, content]) => ({
-		name,
-		content,
-		target: packagePath(name)
-	}));
-	const targetOwners = /* @__PURE__ */ new Map();
-	for (const { name, target } of resolvedPaths) {
-		const owner = targetOwners.get(target);
-		if (owner) throw new Error(`Snapshot has two generated files that sanitize to the same path "${target}": "${owner}" and "${name}"`);
-		targetOwners.set(target, name);
-	}
-	try {
-		await mkdir(dist);
-		await Promise.all(resolvedPaths.map(async ({ content, target }) => {
-			const path = join(root, target.slice(8));
-			await mkdir(join(path, ".."), { recursive: true });
-			await writeFile(path, content);
-		}));
-		const sourceEntries = resolvedPaths.filter(({ name }) => /\.(?:[cm]?[jt]sx?)$/.test(name)).map(({ target }) => join(root, target.slice(8)));
-		if (sourceEntries.length) await build({
-			entry: sourceEntries,
-			outDir: dist,
-			format: ["esm", "cjs"],
-			dts: false,
-			sourcemap: false,
-			unbundle: true,
-			report: false,
-			logLevel: "silent",
-			fixedExtension: true
-		});
-		const builtEntries = await Promise.all((await Array.fromAsync(glob("**/*", {
-			cwd: dist,
-			withFileTypes: true
-		}))).filter((entry) => entry.isFile()).map(async (entry) => {
-			const filePath = join(entry.parentPath, entry.name);
-			return [`package/dist/${relative(dist, filePath).split(sep).join("/")}`, await readFile(filePath, "utf8")];
-		}));
-		const builtPaths = new Set(builtEntries.map(([path]) => path));
-		const hasBarrel = builtPaths.has("package/dist/index.mjs") && builtPaths.has("package/dist/index.cjs");
-		const barrelFields = hasBarrel ? {
-			main: "./dist/index.cjs",
-			module: "./dist/index.mjs"
-		} : {};
-		const barrelExport = hasBarrel ? { ".": {
-			import: "./dist/index.mjs",
-			require: "./dist/index.cjs"
-		} } : {};
-		const entries = {
-			"package/package.json": JSON.stringify({
-				...packageInfo,
-				type: "module",
-				...barrelFields,
-				exports: {
-					...barrelExport,
-					"./*": {
-						import: "./dist/*.mjs",
-						require: "./dist/*.cjs"
-					}
-				}
-			}, null, 2),
-			...Object.fromEntries(resolvedPaths.map(({ content, target }) => [target, content])),
-			...Object.fromEntries(builtEntries)
-		};
-		const chunks = [];
-		for (const [name, content] of Object.entries(entries)) {
-			const bytes = Buffer.from(content);
-			chunks.push(header(name, bytes.length), bytes, Buffer.alloc((512 - bytes.length % 512) % 512));
-		}
-		const bytes = await gzipAsync(Buffer.concat([...chunks, Buffer.alloc(1024)]));
-		return {
-			bytes,
-			integrity: `sha512-${createHash("sha512").update(bytes).digest("base64")}`
-		};
-	} finally {
-		await rm(root, {
-			recursive: true,
-			force: true
-		});
-	}
-}
-async function uploadSnapshot({ bytes, uploadPath, studioUrl, token, shutdown }) {
-	const uploadUrl = new URL(uploadPath, studioUrl);
-	if (uploadUrl.origin !== new URL(studioUrl).origin) throw new Error("Snapshot upload path must stay on the Studio origin");
-	const timeout = AbortSignal.timeout(UPLOAD_TIMEOUT_MS);
-	const signal = shutdown ? AbortSignal.any([shutdown, timeout]) : timeout;
-	const redirect = await fetch(uploadUrl, {
-		method: "PUT",
-		headers: { Authorization: `Bearer ${token}` },
-		redirect: "manual",
-		signal
-	});
-	const storageUrl = redirect.headers.get("location");
-	if (redirect.status !== 307 || !storageUrl) throw new Error(`Studio did not provide a storage URL (status ${redirect.status})`);
-	const storage = new URL(storageUrl);
-	if (storage.protocol !== "https:" && storage.hostname !== "localhost" && storage.hostname !== "127.0.0.1") throw new Error(`Refusing snapshot upload to ${storage.origin}`);
-	const response = await fetch(storage, {
-		method: "PUT",
-		body: new Uint8Array(bytes),
-		redirect: "error",
-		signal
-	});
-	if (!response.ok) throw new Error(`Snapshot upload failed with status ${response.status}`);
-}
+var version = "5.5.4";
 //#endregion
 //#region src/operations/generations.ts
 const READ_CONCURRENCY = 50;
@@ -2615,6 +1561,7 @@ var StudioSession = class {
 	async #readConfigFileView(source) {
 		if (!this.#canEditConfig) return;
 		try {
+			const { readConfig } = await import("./configFile-BymXUi9P.js");
 			return readConfig(source ?? await read(this.#options.configFile));
 		} catch (error) {
 			await this.#warn(`Could not read ${this.#options.configFile}: ${getErrorMessage(error)}`);
@@ -2787,6 +1734,7 @@ var StudioSession = class {
 				disk: disk ? { hashes: disk.hashes } : void 0
 			};
 		} finally {
+			this.#lastGeneration = void 0;
 			if (root !== this.#options.root) await removeJobRoot(root);
 			this.#isGenerating = false;
 		}
@@ -2817,6 +1765,7 @@ var StudioSession = class {
 		}
 		if (this.#isGenerating) return refuse("a generation is in progress");
 		try {
+			const { writeConfigEdits } = await import("./configFile-BymXUi9P.js");
 			const { source: patched, outcomes, changed } = await writeConfigEdits({
 				filePath: configFile,
 				edits
@@ -2848,6 +1797,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 { files } = await this.#generations.read({
 				generation,
 				source: "output",