@kubb/cli 5.0.0-beta.5 → 5.0.0-beta.51

package/LICENSE

@@ -1,14 +1,21 @@
-Copyright (c) 2026 Stijn Van Hulle
-
-This repository contains software under two licenses:
+MIT License
 
-1. Most of the code in this repository is licensed under the
-   MIT License — see licenses/LICENSE-MIT for the full license text.
+Copyright (c) 2026 Stijn Van Hulle
 
-2. The following components are licensed under the
-   GNU Affero General Public License v3.0 or later (AGPL-3.0-or-later)
-   — see licenses/LICENSE-AGPL-3.0 for the full license text:
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
 
-   - packages/agent (published as @kubb/agent)
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
 
-Each package's own LICENSE file or package.json specifies its applicable license.
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,95 +1,215 @@
 <div align="center">
-  <h1>Kubb Cli</h1>
   <a href="https://kubb.dev" target="_blank" rel="noopener noreferrer">
-    <img width="180" src="https://raw.githubusercontent.com/kubb-labs/kubb/main/assets/logo.png" alt="Kubb logo">
+    <img src="https://kubb.dev/og.png" alt="Kubb banner">
   </a>
 
 [![npm version][npm-version-src]][npm-version-href]
 [![npm downloads][npm-downloads-src]][npm-downloads-href]
-[![Coverage][coverage-src]][coverage-href]
+[![Stars][stars-src]][stars-href]
 [![License][license-src]][license-href]
-[![Sponsors][sponsors-src]][sponsors-href]
+[![Node][node-src]][node-href]
 
 <h4>
-    <a href="https://codesandbox.io/s/github/kubb-labs/kubb/tree/main//examples/typescript" target="_blank">View Demo</a>
-    <span> · </span>
-      <a href="https://kubb.dev/" target="_blank">Documentation</a>
-    <span> · </span>
-      <a href="https://github.com/kubb-labs/kubb/issues/" target="_blank">Report Bug</a>
-    <span> · </span>
-      <a href="https://github.com/kubb-labs/kubb/issues/" target="_blank">Request Feature</a>
-  </h4>
+<a href="https://kubb.dev" target="_blank">Documentation</a>
+<span> · </span>
+<a href="https://github.com/kubb-labs/kubb/issues/" target="_blank">Report Bug</a>
+<span> · </span>
+<a href="https://github.com/kubb-labs/kubb/issues/" target="_blank">Request Feature</a>
+</h4>
 </div>
 
+<br />
+
+# @kubb/cli
+
+### The command-line interface for Kubb
+
+Official CLI for Kubb. Run `kubb generate` to transform OpenAPI/Swagger specs into TypeScript types, API clients, hooks, validators, and mocks. Includes interactive project setup (`kubb init`), spec validation, watch mode, and an MCP server.
+
+## Installation
+
+```bash
+bun add -D @kubb/cli
+# or
+pnpm add -D @kubb/cli
+# or
+npm install -D @kubb/cli
+```
+
 ## Commands
 
+- [`kubb init`](#kubb-init) — scaffold a new project
+- [`kubb generate`](#kubb-generate) — run code generation
+- [`kubb validate`](#kubb-validate) — validate an OpenAPI spec
+- [`kubb mcp`](#kubb-mcp) — start the MCP server for AI assistants
+
+---
+
 ### `kubb init`
 
-Initialize a new Kubb project with an interactive setup wizard.
+Scaffold a `kubb.config.ts` and install plugins for code generation from an OpenAPI spec. Run without flags for an interactive setup wizard, or pass flags to skip the prompts.
 
 ```bash
 npx kubb init
 ```
 
-Use the `-y` / `--yes` flag to skip all prompts and accept the defaults:
+#### Options
+
+| Flag               | Short | Type    | Default          | Description                                |
+| ------------------ | ----- | ------- | ---------------- | ------------------------------------------ |
+| `--yes`            | `-y`  | boolean | `false`          | Skip all prompts and use defaults          |
+| `--input <path>`   | `-i`  | string  | `./openapi.yaml` | Path to the OpenAPI specification          |
+| `--output <path>`  | `-o`  | string  | `./src/gen`      | Output directory for generated files       |
+| `--plugins <list>` |       | string  |                  | Comma-separated list of plugins to install |
+
+Available plugin values for `--plugins`: `plugin-ts`, `plugin-client`, `plugin-react-query`, `plugin-vue-query`, `plugin-zod`, `plugin-faker`, `plugin-msw`, `plugin-cypress`, `plugin-mcp`, `plugin-redoc`.
+
+#### Examples
 
 ```bash
-npx kubb init -y
-```
+# Interactive wizard
+npx kubb init
 
-Defaults when using `-y`:
+# Accept all defaults
+npx kubb init --yes
 
-- Input path: `./openapi.yaml`
-- Output path: `./src/gen`
-- Plugins: OpenAPI Parser + TypeScript
+# Fully non-interactive
+npx kubb init --input ./openapi.yaml --output ./src/gen --plugins plugin-ts,plugin-zod
+
+# Select specific plugins only
+npx kubb init --plugins plugin-ts,plugin-client,plugin-react-query
+```
 
-This command will:
+The wizard will:
 
-1. Detect or create a `package.json` if it doesn't exist
-2. Prompt you for your OpenAPI specification path (default: `./openapi.yaml`)
-3. Ask for the output directory for generated files (default: `./src/gen`)
-4. Let you select which Kubb plugins to use (default: OpenAPI Parser + TypeScript)
+1. Detect or create a `package.json` if one does not exist
+2. Prompt for your OpenAPI specification path (default: `./openapi.yaml`)
+3. Ask for the output directory (default: `./src/gen`)
+4. Let you choose which plugins to install
 5. Install the selected packages using your package manager (npm, pnpm, yarn, or bun)
-6. Generate a `kubb.config.ts` file with your chosen configuration
+6. Generate a `kubb.config.ts` with your chosen configuration
+
+---
 
 ### `kubb generate`
 
-Generate files based on your `kubb.config.ts` configuration.
+Generate TypeScript types, API clients, React Query hooks, Zod schemas, and more from an OpenAPI specification. Reads `kubb.config.ts` by default. Pass an OpenAPI file path as the first argument to override the input without editing the config.
 
 ```bash
 npx kubb generate
 ```
 
-Options:
+#### Options
+
+| Flag                 | Short | Type    | Default | Description                                                                                         |
+| -------------------- | ----- | ------- | ------- | --------------------------------------------------------------------------------------------------- |
+| `[input]`            |       | string  |         | OpenAPI file path — overrides `input.path` in the config                                            |
+| `--config <path>`    | `-c`  | string  |         | Path to the Kubb config file                                                                        |
+| `--logLevel <level>` | `-l`  | string  | `info`  | Log level: `silent`, `info`, or `verbose`                                                           |
+| `--watch`            | `-w`  | boolean | `false` | Re-generate whenever the input file changes                                                         |
+| `--verbose`          | `-v`  | boolean | `false` | Override log level to `verbose`                                                                     |
+| `--silent`           | `-s`  | boolean | `false` | Override log level to `silent`                                                                      |
+| `--reporter <names>` |       | string  | `cli`   | Reporters that render the run, comma-separated: `cli`, `json`, `file`. Overrides `config.reporters` |
+| `--no-cache`         |       | boolean | `false` | Disable the incremental build cache and regenerate everything                                       |
+
+#### Examples
+
+```bash
+# Use kubb.config.ts in the current directory
+npx kubb generate
+
+# Override the input spec without editing the config
+npx kubb generate ./openapi.yaml
+
+# Point to a custom config file
+npx kubb generate --config ./configs/kubb.config.ts
+
+# Watch for changes and regenerate automatically
+npx kubb generate --watch
 
-- `-c, --config <path>` - Path to the Kubb config file
-- `-l, --logLevel <level>` - Set log level (silent, info, verbose, debug)
-- `-w, --watch` - Watch mode based on the input file
-- `-d, --debug` - Enable debug mode
-- `-v, --verbose` - Enable verbose mode
-- `-s, --silent` - Enable silent mode
+# Verbose output
+npx kubb generate --verbose
+
+# Write a JSON run report alongside the CLI output
+npx kubb generate --reporter cli,json
+```
+
+---
 
 ### `kubb validate`
 
-Validate a Swagger/OpenAPI file.
+Parse and validate an OpenAPI/Swagger file for structural correctness. Reports schema errors, missing required fields, and malformed references. Use this before running `generate` to catch spec issues early.
 
 ```bash
-npx kubb validate <path-to-openapi>
+npx kubb validate --input <path-or-url>
 ```
 
+#### Options
+
+| Flag             | Short | Type   | Required | Description                                         |
+| ---------------- | ----- | ------ | -------- | --------------------------------------------------- |
+| `--input <path>` | `-i`  | string | ✅       | Path or URL to the OpenAPI/Swagger file to validate |
+
+#### Examples
+
+```bash
+# Validate a local file
+npx kubb validate --input ./openapi.yaml
+
+# Validate a remote spec
+npx kubb validate --input https://petstore3.swagger.io/api/v3/openapi.json
+```
+
+---
+
 ### `kubb mcp`
 
-Start the MCP server to enable the MCP client to interact with the LLM.
+Start a Model Context Protocol (MCP) server that exposes Kubb code generation as a tool for AI assistants. Once running, configure your AI client (Claude, Cursor, Windsurf, etc.) to connect — the assistant can then call `kubb generate` directly without leaving the chat.
+
+Runs over **stdio** by default (compatible with all MCP clients). Pass `--port` to expose an HTTP server instead.
+
+```bash
+npx kubb mcp
+```
+
+#### Options
+
+| Flag                | Short | Type   | Default     | Description                               |
+| ------------------- | ----- | ------ | ----------- | ----------------------------------------- |
+| `--port <number>`   | `-p`  | string |             | Port for HTTP MCP server (omit for stdio) |
+| `--host <hostname>` |       | string | `localhost` | Hostname to bind to (HTTP mode only)      |
+
+#### Examples
 
 ```bash
+# stdio mode (recommended for Claude Desktop, Cursor, etc.)
 npx kubb mcp
+
+# HTTP mode
+npx kubb mcp --port 3001
+```
+
+#### MCP client configuration
+
+Add the following to your MCP client config (e.g. Claude Desktop's `claude_desktop_config.json`):
+
+```json
+{
+  "mcpServers": {
+    "kubb": {
+      "command": "npx",
+      "args": ["kubb", "mcp"]
+    }
+  }
+}
 ```
 
 ## Supporting Kubb
 
-Kubb uses an MIT-licensed open source project with its ongoing development made possible entirely by the support of Sponsors. If you would like to become a sponsor, please consider:
+Kubb is an open source project, and its development is funded entirely by sponsors. If you would like to become a sponsor, please consider:
 
 - [Become a Sponsor on GitHub](https://github.com/sponsors/stijnvanhulle)
+- [See sponsorship tiers and our sponsors](https://kubb.dev/sponsors)
 
 <p align="center">
   <a href="https://github.com/sponsors/stijnvanhulle">
@@ -97,19 +217,19 @@ Kubb uses an MIT-licensed open source project with its ongoing development made
   </a>
 </p>
 
+## License
+
+[MIT](https://github.com/kubb-labs/kubb/blob/main/licenses/LICENSE-MIT)
+
 <!-- Badges -->
 
-[npm-version-src]: https://img.shields.io/npm/v/@kubb/cli?flat&colorA=18181B&colorB=f58517
-[npm-version-href]: https://npmjs.com/package/@kubb/cli
-[npm-downloads-src]: https://img.shields.io/npm/dm/@kubb/cli?flat&colorA=18181B&colorB=f58517
-[npm-downloads-href]: https://npmjs.com/package/@kubb/cli
-[license-src]: https://img.shields.io/github/license/kubb-labs/kubb.svg?flat&colorA=18181B&colorB=f58517
+[npm-version-src]: https://shieldcn.dev/npm/v/@kubb/cli.svg?variant=secondary&size=xs&theme=zinc&mode=dark
+[npm-version-href]: https://npmx.dev/package/@kubb/cli
+[npm-downloads-src]: https://shieldcn.dev/npm/dm/@kubb/cli.svg?variant=secondary&size=xs&theme=zinc&mode=dark
+[npm-downloads-href]: https://npmx.dev/package/@kubb/cli
+[stars-src]: https://shieldcn.dev/github/stars/kubb-labs/kubb.svg?variant=secondary&size=xs&theme=zinc&mode=dark
+[stars-href]: https://github.com/kubb-labs/kubb
+[license-src]: https://shieldcn.dev/npm/license/@kubb/cli.svg?variant=secondary&size=xs&theme=zinc
 [license-href]: https://github.com/kubb-labs/kubb/blob/main/LICENSE
-[build-src]: https://img.shields.io/github/actions/workflow/status/kubb-labs/kubb/ci.yaml?style=flat&colorA=18181B&colorB=f58517
-[build-href]: https://www.npmjs.com/package/@kubb/cli
-[minified-src]: https://img.shields.io/bundlephobia/min/@kubb/cli?style=flat&colorA=18181B&colorB=f58517
-[minified-href]: https://www.npmjs.com/package/@kubb/cli
-[coverage-src]: https://img.shields.io/codecov/c/github/kubb-labs/kubb?style=flat&colorA=18181B&colorB=f58517
-[coverage-href]: https://www.npmjs.com/package/@kubb/cli
-[sponsors-src]: https://img.shields.io/github/sponsors/stijnvanhulle?style=flat&colorA=18181B&colorB=f58517
-[sponsors-href]: https://github.com/sponsors/stijnvanhulle/
+[node-src]: https://shieldcn.dev/npm/node/@kubb/cli.svg?variant=secondary&size=xs&theme=zinc&mode=dark
+[node-href]: https://npmx.dev/package/@kubb/cli

package/dist/Telemetry-BG80bcoQ.cjs

@@ -0,0 +1,350 @@
+const require_chunk = require("./chunk-Bx3C2hgW.cjs");
+let node_crypto = require("node:crypto");
+let node_dns = require("node:dns");
+let node_os = require("node:os");
+node_os = require_chunk.__toESM(node_os, 1);
+let node_process = require("node:process");
+node_process = require_chunk.__toESM(node_process, 1);
+//#region ../../internals/utils/src/env.ts
+/**
+* Returns `true` when the process is running in a CI environment.
+* Covers GitHub Actions, GitLab CI, CircleCI, Travis CI, Jenkins, Bitbucket,
+* TeamCity, Buildkite, and Azure Pipelines.
+*
+* @example
+* ```ts
+* if (isCIEnvironment()) {
+*   logger.level = 'error'
+* }
+* ```
+*/
+function isCIEnvironment() {
+	return !!(process.env.CI || process.env.GITHUB_ACTIONS || process.env.GITLAB_CI || process.env.BITBUCKET_BUILD_NUMBER || process.env.JENKINS_URL || process.env.CIRCLECI || process.env.TRAVIS || process.env.TEAMCITY_VERSION || process.env.BUILDKITE || process.env.TF_BUILD);
+}
+/**
+* Returns `true` when the process has an interactive TTY with a valid terminal
+* width and is not running in CI.
+*
+* Some IDE-embedded terminals report `isTTY = true` but set `columns` to `0`,
+* which breaks clack's box-drawing helpers (they call `String.prototype.repeat`
+* with a negative count and throw a `RangeError`).  We therefore require a
+* positive column count before declaring the TTY usable.
+*
+* @example
+* ```ts
+* if (canUseTTY()) {
+*   renderProgressBar()
+* }
+* ```
+*/
+function canUseTTY() {
+	return !!process.stdout.isTTY && (process.stdout.columns ?? 0) > 0 && !isCIEnvironment();
+}
+//#endregion
+//#region ../../internals/utils/src/network.ts
+/**
+* Well-known stable domains used as DNS probes to check internet connectivity.
+*/
+const TEST_DOMAINS = [
+	"dns.google.com",
+	"cloudflare.com",
+	"one.one.one.one"
+];
+/**
+* Returns `true` when the system has internet connectivity.
+* Probes DNS resolution against well-known stable domains.
+*
+* @example
+* ```ts
+* if (await isOnline()) {
+*   await fetchLatestVersion()
+* }
+* ```
+*/
+async function isOnline() {
+	for (const domain of TEST_DOMAINS) try {
+		await node_dns.promises.resolve(domain);
+		return true;
+	} catch {}
+	return false;
+}
+/**
+* Executes `fn` only when the system is online. Returns `null` when offline or on error.
+*
+* @example
+* ```ts
+* const version = await executeIfOnline(() => fetchLatestVersion('kubb'))
+* // null when offline
+* ```
+*/
+async function executeIfOnline(fn) {
+	if (!await isOnline()) return null;
+	try {
+		return await fn();
+	} catch {
+		return null;
+	}
+}
+//#endregion
+//#region ../../internals/utils/src/runtime.ts
+/**
+* Returns `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 (isBun()) {
+*   await Bun.write(path, data)
+* }
+* ```
+*/
+function isBun() {
+	return typeof Bun !== "undefined";
+}
+/**
+* Returns `true` when the current process is running under Deno.
+*/
+function isDeno() {
+	return typeof globalThis.Deno !== "undefined";
+}
+/**
+* Returns the name of the runtime executing the current process.
+*
+* @example
+* ```ts
+* getRuntimeName() // 'bun' when run with `bun kubb`, 'node' otherwise
+* ```
+*/
+function getRuntimeName() {
+	if (isBun()) return "bun";
+	if (isDeno()) return "deno";
+	return "node";
+}
+/**
+* Returns the version of the active runtime, or an empty string when it cannot be read.
+*
+* @example
+* ```ts
+* getRuntimeVersion() // '1.3.11' under Bun, '22.22.2' under Node
+* ```
+*/
+function getRuntimeVersion() {
+	if (isBun()) return process.versions.bun ?? "";
+	if (isDeno()) return globalThis.Deno?.version?.deno ?? "";
+	return process.versions?.node ?? "";
+}
+//#endregion
+//#region src/constants.ts
+/**
+* NPM registry endpoint used to check for @kubb/cli updates.
+*/
+const KUBB_NPM_PACKAGE_URL = "https://registry.npmjs.org/@kubb/cli/latest";
+/**
+* OpenTelemetry ingestion endpoint for anonymous usage telemetry.
+*/
+const OTLP_ENDPOINT = "https://otlp.kubb.dev";
+"─".repeat(27);
+/**
+* Glob pattern for paths the file watcher ignores.
+*/
+const WATCHER_IGNORED_PATHS = "**/{.git,node_modules}/**";
+/**
+* Flags that short-circuit execution (help/version), no telemetry notice is shown.
+*/
+const QUIET_FLAGS = new Set([
+	"--help",
+	"-h",
+	"--version",
+	"-v"
+]);
+//#endregion
+//#region src/Telemetry.ts
+/**
+* Anonymous OTLP usage telemetry for the Kubb run. All methods are static, so call them as
+* `Telemetry.build(...)`, `Telemetry.send(...)`, and `Telemetry.isDisabled()`. No file paths,
+* OpenAPI specs, or secrets are ever included, and sending fails silently to never break a run.
+*/
+var Telemetry = class Telemetry {
+	/**
+	* Returns `true` when telemetry is disabled via `DO_NOT_TRACK` or `KUBB_DISABLE_TELEMETRY`.
+	*/
+	static isDisabled() {
+		return node_process.default.env["DO_NOT_TRACK"] === "1" || node_process.default.env["DO_NOT_TRACK"] === "true" || node_process.default.env["KUBB_DISABLE_TELEMETRY"] === "1" || node_process.default.env["KUBB_DISABLE_TELEMETRY"] === "true";
+	}
+	/**
+	* Build an anonymous telemetry payload from a completed generation run.
+	*/
+	static build(options) {
+		const [seconds, nanoseconds] = node_process.default.hrtime(options.hrStart);
+		const duration = Math.round(seconds * 1e3 + nanoseconds / 1e6);
+		return {
+			command: options.command,
+			kubbVersion: options.kubbVersion,
+			nodeVersion: node_process.default.versions.node.split(".")[0],
+			runtime: getRuntimeName(),
+			runtimeVersion: getRuntimeVersion().split(".")[0],
+			platform: node_os.default.platform(),
+			ci: isCIEnvironment(),
+			plugins: options.plugins ?? [],
+			duration,
+			filesCreated: options.filesCreated ?? 0,
+			status: options.status
+		};
+	}
+	/**
+	* Convert a {@link TelemetryEvent} into an OTLP-compatible JSON trace payload.
+	* See https://opentelemetry.io/docs/languages/sdk-configuration/otlp-exporter/
+	*/
+	static buildOtlpPayload(event) {
+		const traceId = (0, node_crypto.randomBytes)(16).toString("hex");
+		const spanId = (0, node_crypto.randomBytes)(8).toString("hex");
+		const endTimeNs = BigInt(Date.now()) * 1000000n;
+		const startTimeNs = endTimeNs - BigInt(event.duration) * 1000000n;
+		const attributes = [
+			{
+				key: "kubb.command",
+				value: { stringValue: event.command }
+			},
+			{
+				key: "kubb.version",
+				value: { stringValue: event.kubbVersion }
+			},
+			{
+				key: "kubb.node_version",
+				value: { stringValue: event.nodeVersion }
+			},
+			{
+				key: "kubb.runtime",
+				value: { stringValue: event.runtime }
+			},
+			{
+				key: "kubb.runtime_version",
+				value: { stringValue: event.runtimeVersion }
+			},
+			{
+				key: "kubb.platform",
+				value: { stringValue: event.platform }
+			},
+			{
+				key: "kubb.ci",
+				value: { boolValue: event.ci }
+			},
+			{
+				key: "kubb.files_created",
+				value: { intValue: event.filesCreated }
+			},
+			{
+				key: "kubb.status",
+				value: { stringValue: event.status }
+			},
+			{
+				key: "kubb.plugins",
+				value: { arrayValue: { values: event.plugins.map((p) => ({ kvlistValue: { values: [{
+					key: "name",
+					value: { stringValue: p.name }
+				}, {
+					key: "options",
+					value: { stringValue: JSON.stringify({
+						...p.options,
+						usedEnumNames: void 0
+					}) }
+				}] } })) } }
+			}
+		];
+		return { resourceSpans: [{
+			resource: { attributes: [
+				{
+					key: "service.name",
+					value: { stringValue: "kubb-core" }
+				},
+				{
+					key: "service.version",
+					value: { stringValue: event.kubbVersion }
+				},
+				{
+					key: "telemetry.sdk.language",
+					value: { stringValue: "nodejs" }
+				}
+			] },
+			scopeSpans: [{
+				scope: {
+					name: "kubb-core",
+					version: event.kubbVersion
+				},
+				spans: [{
+					traceId,
+					spanId,
+					name: event.command,
+					kind: 1,
+					startTimeUnixNano: String(startTimeNs),
+					endTimeUnixNano: String(endTimeNs),
+					attributes,
+					status: { code: event.status === "success" ? 1 : 2 }
+				}]
+			}]
+		}] };
+	}
+	/**
+	* Send an anonymous telemetry event to the Kubb OTLP endpoint. Respects `DO_NOT_TRACK` and
+	* `KUBB_DISABLE_TELEMETRY`, and fails silently so telemetry never interrupts a run.
+	*/
+	static async send(event) {
+		if (Telemetry.isDisabled()) return;
+		await executeIfOnline(async () => {
+			try {
+				await fetch(`${OTLP_ENDPOINT}/v1/traces`, {
+					method: "POST",
+					headers: {
+						"Content-Type": "application/json",
+						"Kubb-Telemetry-Version": "1",
+						"Kubb-Telemetry-Source": "kubb-core"
+					},
+					body: JSON.stringify(Telemetry.buildOtlpPayload(event)),
+					signal: AbortSignal.timeout(5e3)
+				});
+			} catch (_e) {}
+		});
+	}
+};
+//#endregion
+Object.defineProperty(exports, "KUBB_NPM_PACKAGE_URL", {
+	enumerable: true,
+	get: function() {
+		return KUBB_NPM_PACKAGE_URL;
+	}
+});
+Object.defineProperty(exports, "QUIET_FLAGS", {
+	enumerable: true,
+	get: function() {
+		return QUIET_FLAGS;
+	}
+});
+Object.defineProperty(exports, "Telemetry", {
+	enumerable: true,
+	get: function() {
+		return Telemetry;
+	}
+});
+Object.defineProperty(exports, "WATCHER_IGNORED_PATHS", {
+	enumerable: true,
+	get: function() {
+		return WATCHER_IGNORED_PATHS;
+	}
+});
+Object.defineProperty(exports, "canUseTTY", {
+	enumerable: true,
+	get: function() {
+		return canUseTTY;
+	}
+});
+Object.defineProperty(exports, "executeIfOnline", {
+	enumerable: true,
+	get: function() {
+		return executeIfOnline;
+	}
+});
+
+//# sourceMappingURL=Telemetry-BG80bcoQ.cjs.map