@kubb/core 5.0.0-beta.11 → 5.0.0-beta.110

package/dist/usingCtx-njZUKKsY.js

@@ -0,0 +1,822 @@
+import "./rolldown-runtime-C0LytTxp.js";
+import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import { dirname, isAbsolute, relative, resolve } from "node:path";
+import { ast, extractStringsFromNodes } from "@kubb/ast";
+import { EventEmitter } from "node:events";
+//#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
+/**
+* Thrown when one or more errors occur during a Kubb build.
+* Carries the full list of underlying errors on `errors`.
+*
+* @example
+* ```ts
+* throw new BuildError('Build failed', { errors: [err1, err2] })
+* ```
+*/
+var BuildError = class extends Error {
+	errors;
+	constructor(message, options) {
+		super(message, { cause: options.cause });
+		this.name = "BuildError";
+		this.errors = options.errors;
+	}
+};
+/**
+* Coerces an unknown thrown value to an `Error` instance.
+* Returns the value as-is when it is already an `Error`; otherwise wraps it with `String(value)`.
+*
+* @example
+* ```ts
+* try { ... } catch(err) {
+*   throw new BuildError('Build failed', { cause: toError(err), errors: [] })
+* }
+* ```
+*/
+function toError(value) {
+	return value instanceof Error ? value : new Error(String(value));
+}
+/**
+* Extracts a human-readable message from any thrown value.
+*
+* @example
+* ```ts
+* getErrorMessage(new Error('oops')) // 'oops'
+* getErrorMessage('plain string')    // 'plain string'
+* ```
+*/
+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" });
+}
+/**
+* Whether `stored` already holds `source`, comparing on the trimmed text rather than the exact
+* bytes. Surrounding whitespace is what a formatter adds and what editors strip, and neither is a
+* reason to rewrite the file.
+*
+* Both sides are trimmed, so a storage that keeps bytes verbatim settles on the same answer as one
+* that normalizes what it stores. Trimming only `stored` would leave a source with leading
+* whitespace rewritten on every build, since the stored copy keeps the whitespace the comparison
+* has already dropped.
+*/
+function matchesStored({ stored, source }) {
+	return stored.trim() === source.trim();
+}
+/**
+* Writes `data` to `path`, trimming surrounding whitespace and ending the file with a single newline
+* the way prettier, biome, and oxfmt all do.
+* Skips the write when the trimmed content is empty, or when the file already holds that content.
+* Creates any missing parent directories automatically.
+* When `sanity` is `true`, re-reads the file after writing and throws if the content does not match.
+*
+* @example
+* ```ts
+* await write('./src/Pet.ts', source)         // writes and returns the trimmed content plus a newline
+* await write('./src/Pet.ts', source)         // null — file unchanged
+* await write('./src/Pet.ts', '  ')           // null — empty content skipped
+* ```
+*/
+async function write(path, data, options = {}) {
+	const trimmed = data.trim();
+	if (trimmed === "") return null;
+	const content = `${trimmed}\n`;
+	const resolved = resolve(path);
+	if (runtime.isBun) {
+		const file = Bun.file(resolved);
+		if (matchesStored({
+			stored: await file.exists() ? await file.text() : "",
+			source: trimmed
+		})) return null;
+		await Bun.write(resolved, content);
+		return content;
+	}
+	try {
+		if (matchesStored({
+			stored: await readFile(resolved, { encoding: "utf-8" }),
+			source: trimmed
+		})) return null;
+	} catch {}
+	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" });
+	}
+	if (options.sanity) {
+		const savedData = await readFile(resolved, { encoding: "utf-8" });
+		if (savedData !== content) throw new Error(`Sanity check failed for ${path}\n\nData[${data.length}]:\n${data}\n\nSaved[${savedData.length}]:\n${savedData}\n`);
+		return savedData;
+	}
+	return content;
+}
+/**
+* Recursively removes `path`. Silently succeeds when `path` does not exist.
+*
+* @example
+* ```ts
+* await clean('./dist')
+* ```
+*/
+async function clean(path) {
+	return rm(path, {
+		recursive: true,
+		force: true
+	});
+}
+/**
+* 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.
+*
+* Guards destructive operations: before wiping an output directory, check that it does not contain
+* the project root, otherwise a `clean` would delete `kubb.config` and every source file.
+*
+* @example
+* isPathInside('./src/gen', '.')   // true  — nested inside the root
+* isPathInside('.', '.')           // true  — the same directory counts as inside
+* isPathInside('.', './src/gen')   // false — the root is not inside its own output
+* isPathInside('../other', '.')    // false — escapes the root
+*/
+function isPathInside(path, parent) {
+	const resolvedPath = resolve(path);
+	const resolvedParent = resolve(parent);
+	if (resolvedPath === resolvedParent) return true;
+	const rel = relative(resolvedParent, resolvedPath);
+	return rel !== "" && !rel.startsWith("..") && !isAbsolute(rel);
+}
+/**
+* Converts a filesystem path to use POSIX (`/`) separators.
+*
+* Most of the codebase compares and composes paths as strings (prefix matching, joining for
+* import specifiers, splitting on `/`). On POSIX `path.resolve` already returns `/`-separated
+* paths, but on Windows it returns `\`-separated paths, which breaks every such comparison.
+*
+* Routing every path that crosses a module boundary through `toPosixPath` keeps the rest of the
+* code platform-agnostic. The conversion runs unconditionally so Windows-specific behavior is
+* exercisable from POSIX CI.
+*
+* @example
+* toPosixPath('C:\\repo\\src\\pet.ts') // 'C:/repo/src/pet.ts'
+*/
+function toPosixPath(filePath) {
+	return filePath.replaceAll("\\", "/");
+}
+/**
+* Builds a nested file path from a dotted name. Splits on dots that precede a letter
+* (so version numbers embedded in operationIds like `v2025.0` stay intact), camelCases
+* every earlier segment, applies `caseLast` to the final segment, and joins with `/`.
+*
+* Empty segments are dropped before joining. They arise when the name starts with a dot
+* followed by a letter (e.g. `..Schema` splits into `['..', 'Schema']` and `'..'` cases to
+* an empty string). Without this a leading `/` would form, which `path.resolve` reads as an
+* absolute path, letting generated files escape the configured output directory.
+*
+* @example Nested path from a dotted name
+* `toFilePath('pet.petId') // 'pet/petId'`
+*
+* @example PascalCase the final segment
+* `toFilePath('pet.Pet', pascalCase) // 'pet/Pet'`
+*
+* @example Suffix applied to the final segment only
+* `toFilePath('tag.tag', (part) => camelCase(part, { suffix: 'schema' })) // 'tag/tagSchema'`
+*/
+function toFilePath(name, caseLast = camelCase) {
+	const parts = name.split(/\.(?=[a-zA-Z])/);
+	return parts.map((part, i) => i === parts.length - 1 ? caseLast(part) : camelCase(part)).filter(Boolean).join("/");
+}
+//#endregion
+//#region ../../internals/utils/src/promise.ts
+/**
+* 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.
+*
+* @example
+* ```ts
+* await inParallel({ items: files, limit: 50, run: (file) => storage.writeItem(file.path, file.source) })
+* ```
+*/
+async function inParallel({ items, limit, run }) {
+	const queue = items.entries();
+	const worker = async () => {
+		for (const [index, item] of queue) await run(item, index);
+	};
+	await Promise.all(Array.from({ length: Math.min(limit, items.length) }, () => worker()));
+}
+//#endregion
+//#region src/constants.ts
+/**
+* Plugin `include` filter types that select operations directly. When one of these is set
+* without a `schemaName` include, the generate phase pre-scans operations to compute the set
+* of schemas they reach, so unreachable schemas can be pruned for that plugin.
+*/
+const OPERATION_FILTER_TYPES = /* @__PURE__ */ new Set([
+	"tag",
+	"operationId",
+	"path",
+	"method",
+	"contentType"
+]);
+/**
+* Stable codes Kubb attaches to a `Diagnostic`. Each maps to a known failure mode
+* and stays stable so it can be referenced in tooling and (later) docs. Reference
+* these instead of inlining the string at a throw site.
+*/
+const diagnosticCode = {
+	/**
+	* Fallback for an unstructured error with no specific code.
+	*/
+	unknown: "KUBB_UNKNOWN",
+	/**
+	* The file or URL set as `input` could not be read.
+	*/
+	inputNotFound: "KUBB_INPUT_NOT_FOUND",
+	/**
+	* A URL set as `input` (or referenced by a `$ref`) answered with a 4xx or 5xx status
+	* instead of the document.
+	*/
+	inputRequestFailed: "KUBB_INPUT_REQUEST_FAILED",
+	/**
+	* A URL set as `input` (or referenced by a `$ref`) never answered, so the request failed
+	* before a status was returned.
+	*/
+	inputUnreachable: "KUBB_INPUT_UNREACHABLE",
+	/**
+	* An adapter was configured without an `input`.
+	*/
+	inputRequired: "KUBB_INPUT_REQUIRED",
+	/**
+	* `input` uses the v4 `{ path }` / `{ data }` wrapper, which v5 reads as a parsed
+	* document instead of a pointer to one.
+	*/
+	legacyInput: "KUBB_LEGACY_INPUT",
+	/**
+	* The parsed `input` carries no `openapi` or `swagger` version, so it is not a
+	* document the adapter can read.
+	*/
+	invalidDocument: "KUBB_INVALID_DOCUMENT",
+	/**
+	* A `$ref` (or equivalent reference) could not be resolved in the source document.
+	*/
+	refNotFound: "KUBB_REF_NOT_FOUND",
+	/**
+	* A server variable value is not allowed by its `enum`.
+	*/
+	invalidServerVariable: "KUBB_INVALID_SERVER_VARIABLE",
+	/**
+	* A required plugin is missing from the config.
+	*/
+	pluginNotFound: "KUBB_PLUGIN_NOT_FOUND",
+	/**
+	* A plugin threw while generating.
+	*/
+	pluginFailed: "KUBB_PLUGIN_FAILED",
+	/**
+	* A plugin reported a non-fatal warning through `ctx.warn`.
+	*/
+	pluginWarning: "KUBB_PLUGIN_WARNING",
+	/**
+	* A plugin reported an informational message through `ctx.info`.
+	*/
+	pluginInfo: "KUBB_PLUGIN_INFO",
+	/**
+	* A schema uses a `format` Kubb does not map to a specific type. Reserved for
+	* adapters to emit as a `warning`.
+	*/
+	unsupportedFormat: "KUBB_UNSUPPORTED_FORMAT",
+	/**
+	* A referenced schema or operation is marked `deprecated`. Reserved for adapters
+	* to emit as an `info`.
+	*/
+	deprecated: "KUBB_DEPRECATED",
+	/**
+	* An adapter is required but the config has none. The build cannot read the input
+	* without one.
+	*/
+	adapterRequired: "KUBB_ADAPTER_REQUIRED",
+	/**
+	* A resolved output path escapes the output directory, which can stem from a path
+	* traversal in the spec or a misconfigured `group.name`.
+	*/
+	pathTraversal: "KUBB_PATH_TRAVERSAL",
+	/**
+	* `output.clean` is enabled but `output.path` resolves to the project root or a parent of it,
+	* so cleaning would delete kubb.config and every source file.
+	*/
+	cleanRoot: "KUBB_CLEAN_ROOT",
+	/**
+	* A plugin's options are invalid, for example `output.mode: 'file'` paired with a `group` option.
+	*/
+	invalidPluginOptions: "KUBB_INVALID_PLUGIN_OPTIONS",
+	/**
+	* A post-generate command (`output.postGenerate`) exited with a failure.
+	*/
+	postGenerateFailed: "KUBB_POST_GENERATE_FAILED",
+	/**
+	* The formatter pass over the generated files failed.
+	*/
+	formatFailed: "KUBB_FORMAT_FAILED",
+	/**
+	* The linter pass over the generated files failed.
+	*/
+	lintFailed: "KUBB_LINT_FAILED",
+	/**
+	* Not a failure. Carries a plugin's elapsed time, summed into the run total.
+	*/
+	performance: "KUBB_PERFORMANCE",
+	/**
+	* Not a failure. A newer Kubb version is available on npm.
+	*/
+	updateAvailable: "KUBB_UPDATE_AVAILABLE"
+};
+//#endregion
+//#region src/Hookable.ts
+/**
+* Typed hook emitter that awaits all async listeners before resolving.
+* Wraps Node's `EventEmitter` with full TypeScript hook-map inference.
+*
+* @example
+* ```ts
+* const hooks = new Hookable<{ build: [name: string] }>()
+* hooks.hook('build', async (name) => { console.log(name) })
+* await hooks.callHook('build', 'petstore') // all listeners awaited
+* ```
+*/
+var Hookable = class {
+	/**
+	* Maximum number of listeners per hook before Node emits a memory-leak warning.
+	* @default 10
+	*/
+	constructor(maxListener = 10) {
+		this.#emitter.setMaxListeners(maxListener);
+	}
+	#emitter = new EventEmitter();
+	/**
+	* Calls `hookName` and awaits all registered listeners sequentially.
+	* Throws if any listener rejects, wrapping the cause with the hook name and serialized arguments.
+	*
+	* @example
+	* ```ts
+	* await hooks.callHook('build', 'petstore')
+	* ```
+	*/
+	callHook(hookName, ...hookArgs) {
+		const listeners = this.#emitter.listeners(hookName);
+		if (listeners.length === 0) return;
+		return this.#emitAll(hookName, listeners, hookArgs);
+	}
+	async #emitAll(hookName, listeners, hookArgs) {
+		for (const listener of listeners) try {
+			await listener(...hookArgs);
+		} catch (err) {
+			let serializedArgs;
+			try {
+				serializedArgs = JSON.stringify(hookArgs);
+			} catch {
+				serializedArgs = String(hookArgs);
+			}
+			throw new Error(`Error in async listener for "${hookName}" with hookArgs ${serializedArgs}`, { cause: toError(err) });
+		}
+	}
+	/**
+	* Registers a persistent listener for `hookName` and returns a function that removes it.
+	*
+	* @example
+	* ```ts
+	* const unhook = hooks.hook('build', async (name) => { console.log(name) })
+	* unhook() // removes it
+	* ```
+	*/
+	hook(hookName, handler) {
+		this.#emitter.on(hookName, handler);
+		return () => this.removeHook(hookName, handler);
+	}
+	/**
+	* Registers every handler in `configHooks` at once and returns a function that removes them
+	* all. Undefined entries are skipped, so a partial hook object registers only its present keys.
+	*
+	* @example
+	* ```ts
+	* const unhook = hooks.addHooks({ build: onBuild, done: onDone })
+	* unhook() // removes both
+	* ```
+	*/
+	addHooks(configHooks) {
+		const unhooks = Object.keys(configHooks).filter((name) => configHooks[name]).map((name) => this.hook(name, configHooks[name]));
+		return () => {
+			for (const unhook of unhooks) unhook();
+		};
+	}
+	/**
+	* Removes a previously registered listener.
+	*
+	* @example
+	* ```ts
+	* hooks.removeHook('build', handler)
+	* ```
+	*/
+	removeHook(hookName, handler) {
+		this.#emitter.off(hookName, handler);
+	}
+	/**
+	* Returns the number of listeners registered for `hookName`.
+	*
+	* @example
+	* ```ts
+	* hooks.hook('build', handler)
+	* hooks.listenerCount('build') // 1
+	* ```
+	*/
+	listenerCount(hookName) {
+		return this.#emitter.listenerCount(hookName);
+	}
+	/**
+	* Raises or lowers the per-hook listener ceiling before Node warns about a memory leak.
+	* Set this above the expected listener count when many listeners attach by design.
+	*
+	* @example
+	* ```ts
+	* hooks.setMaxListeners(40)
+	* ```
+	*/
+	setMaxListeners(max) {
+		this.#emitter.setMaxListeners(max);
+	}
+	/**
+	* Removes all listeners from every hook channel.
+	*
+	* @example
+	* ```ts
+	* hooks.removeAllHooks()
+	* ```
+	*/
+	removeAllHooks() {
+		this.#emitter.removeAllListeners();
+	}
+};
+//#endregion
+//#region src/FileManager.ts
+function joinSources(file) {
+	return file.sources.map((source) => extractStringsFromNodes(source.nodes)).filter(Boolean).join("\n\n");
+}
+async function parseCopy(file) {
+	let content;
+	try {
+		content = await read(file.copy);
+	} catch (err) {
+		throw new Error(`[kubb] Could not copy file into output: ${file.copy}`, { cause: err });
+	}
+	return [
+		file.banner,
+		content,
+		file.footer
+	].filter((segment) => Boolean(segment)).map((segment) => segment.trimEnd()).join("\n");
+}
+function mergeFile(a, b) {
+	return {
+		...a,
+		banner: b.banner,
+		footer: b.footer,
+		copy: b.copy ?? a.copy,
+		sources: a.sources.length ? b.sources.length ? [...a.sources, ...b.sources] : a.sources : b.sources,
+		imports: a.imports.length ? b.imports.length ? [...a.imports, ...b.imports] : a.imports : b.imports,
+		exports: a.exports.length ? b.exports.length ? [...a.exports, ...b.exports] : a.exports : b.exports
+	};
+}
+function isIndexPath(path) {
+	return path.endsWith("/index.ts") || path === "index.ts";
+}
+function compareFiles(a, b) {
+	const lenDiff = a.path.length - b.path.length;
+	if (lenDiff !== 0) return lenDiff;
+	const aIsIndex = isIndexPath(a.path);
+	const bIsIndex = isIndexPath(b.path);
+	if (aIsIndex && !bIsIndex) return 1;
+	if (!aIsIndex && bIsIndex) return -1;
+	return 0;
+}
+function isUnchanged({ stored, source, key, manifest }) {
+	if (stored === null) return false;
+	if (matchesStored({
+		stored,
+		source
+	})) return true;
+	return manifest?.isUpToDate({
+		key,
+		source,
+		disk: stored
+	}) ?? false;
+}
+/**
+* In-memory file store for generated files, and the writer that turns them into source
+* strings on `storage`. Files sharing a `path` are merged (sources/imports/exports
+* concatenated). The `files` getter is sorted by path length (barrel `index.ts` last
+* within a bucket).
+*
+* @example
+* ```ts
+* const manager = new FileManager()
+* manager.upsert(myFile)
+* manager.files // sorted view
+* await manager.write(manager.files, { storage: fsStorage() })
+* ```
+*/
+var FileManager = class {
+	hooks = new Hookable();
+	#cache = /* @__PURE__ */ new Map();
+	#sorted = null;
+	add(...files) {
+		return this.#store(files, false);
+	}
+	upsert(...files) {
+		return this.#store(files, true);
+	}
+	#store(files, mergeExisting) {
+		const batch = files.length > 1 ? this.#dedupe(files) : files;
+		const resolved = [];
+		for (const file of batch) {
+			const existing = this.#cache.get(file.path);
+			const merged = existing && mergeExisting ? ast.factory.createFile(mergeFile(existing, file)) : ast.factory.createFile(file);
+			this.#cache.set(merged.path, merged);
+			resolved.push(merged);
+		}
+		if (resolved.length > 0) this.#sorted = null;
+		return resolved;
+	}
+	#dedupe(files) {
+		const seen = /* @__PURE__ */ new Map();
+		for (const file of files) {
+			const prev = seen.get(file.path);
+			seen.set(file.path, prev ? mergeFile(prev, file) : file);
+		}
+		return [...seen.values()];
+	}
+	clear() {
+		this.#cache.clear();
+		this.#sorted = null;
+	}
+	/**
+	* Releases all stored files and clears every `hooks` listener. Called by the core after
+	* `kubb:build:end`.
+	*/
+	dispose() {
+		this.clear();
+		this.hooks.removeAllHooks();
+	}
+	/**
+	* All stored files in stable sort order (shortest path first, barrel files
+	* last within a length bucket). Returns a cached view, do not mutate.
+	*/
+	get files() {
+		return this.#sorted ??= [...this.#cache.values()].sort(compareFiles);
+	}
+	/**
+	* Converts a file's AST sources (or its `copy` source) into the final on-disk string.
+	*/
+	async parse(file, { parsers } = {}) {
+		if (file.copy) return parseCopy(file);
+		if (!parsers || !file.extname) return joinSources(file);
+		const parser = parsers.get(file.extname);
+		if (!parser) return joinSources(file);
+		return parser.parse(file);
+	}
+	/**
+	* Parses and writes every file through a bounded pool of workers. A small spec runs all its files
+	* at once; a spec with thousands of files keeps at most {@link FILE_CONCURRENCY} parsed sources in
+	* memory rather than holding every source, while still overlapping each file's write with the
+	* next file's parse. Each `update` carries the file's input position, so a consumer can present
+	* the files in generation order even though they finish in whatever order they parse.
+	*
+	* A file the storage already holds is skipped, so a rebuild that generates identical output
+	* writes nothing and leaves every mtime where it was.
+	*/
+	async write(files, { storage, parsers, manifest }) {
+		if (files.length === 0) return;
+		await this.hooks.callHook("start", files);
+		const total = files.length;
+		await inParallel({
+			items: files,
+			limit: 50,
+			run: async (file, index) => {
+				const source = await this.parse(file, { parsers });
+				await this.hooks.callHook("update", {
+					file,
+					source,
+					processed: index + 1,
+					total,
+					percentage: (index + 1) / total * 100
+				});
+				if (!source) return;
+				if (isUnchanged({
+					stored: await storage.readItem(file.path),
+					source,
+					key: file.path,
+					manifest
+				})) return;
+				await storage.writeItem(file.path, source);
+				manifest?.track({
+					key: file.path,
+					source
+				});
+			}
+		});
+		await this.hooks.callHook("end", files);
+	}
+};
+//#endregion
+//#region src/nodeCache.ts
+/**
+* Builds an empty {@link NodeCache} backed by a plain `Map`. Called once per node in the generate
+* walk.
+*/
+function createNodeCache() {
+	const store = /* @__PURE__ */ new Map();
+	return {
+		readItem(key) {
+			return store.get(key);
+		},
+		writeItem(key, value) {
+			store.set(key, value);
+			return value;
+		},
+		ensureItem(key, factory) {
+			if (store.has(key)) return store.get(key);
+			const value = factory();
+			store.set(key, value);
+			return value;
+		}
+	};
+}
+//#endregion
+//#region \0@oxc-project+runtime@0.142.0/helpers/esm/usingCtx.js
+function _usingCtx() {
+	var r = "function" == typeof SuppressedError ? SuppressedError : function(r, e) {
+		var n = Error();
+		return n.name = "SuppressedError", n.error = r, n.suppressed = e, n;
+	};
+	var e = {};
+	var n = [];
+	function using(r, e) {
+		if (null != e) {
+			if (Object(e) !== e) throw new TypeError("using declarations can only be used with objects, functions, null, or undefined.");
+			if (r) var o = e[Symbol.asyncDispose || Symbol["for"]("Symbol.asyncDispose")];
+			if (void 0 === o && (o = e[Symbol.dispose || Symbol["for"]("Symbol.dispose")], r)) var t = o;
+			if ("function" != typeof o) throw new TypeError("Object is not disposable.");
+			t && (o = function o() {
+				try {
+					t.call(e);
+				} catch (r) {
+					return Promise.reject(r);
+				}
+			}), n.push({
+				v: e,
+				d: o,
+				a: r
+			});
+		} else r && n.push({
+			d: e,
+			a: r
+		});
+		return e;
+	}
+	return {
+		e,
+		u: using.bind(null, !1),
+		a: using.bind(null, !0),
+		d: function d() {
+			var o;
+			var t = this.e;
+			var s = 0;
+			function next() {
+				for (; o = n.pop();) try {
+					if (!o.a && 1 === s) return s = 0, n.push(o), Promise.resolve().then(next);
+					if (o.d) {
+						var r = o.d.call(o.v);
+						if (o.a) return s |= 2, Promise.resolve(r).then(next, err);
+					} else s |= 1;
+				} catch (r) {
+					return err(r);
+				}
+				if (1 === s) return t !== e ? Promise.reject(t) : Promise.resolve();
+				if (t !== e) throw t;
+			}
+			function err(n) {
+				return t = t !== e ? new r(n, t) : n, next();
+			}
+			return next();
+		}
+	};
+}
+//#endregion
+export { OPERATION_FILTER_TYPES as a, clean as c, toPosixPath as d, write as f, camelCase as g, toError as h, Hookable as i, isPathInside as l, getErrorMessage as m, createNodeCache as n, diagnosticCode as o, BuildError as p, FileManager as r, inParallel as s, _usingCtx as t, toFilePath as u };
+
+//# sourceMappingURL=usingCtx-njZUKKsY.js.map