@kubb/cli 5.0.0-beta.35 → 5.0.0-beta.37

package/src/runners/generate/run.ts

@@ -5,10 +5,24 @@ import { styleText } from 'node:util'
 import * as clack from '@clack/prompts'
 import type { AsyncEventEmitter } from '@internals/utils'
 import { AsyncEventEmitter as AsyncEventEmitterClass, detectFormatter, detectLinter, executeIfOnline, formatters, linters, toError } from '@internals/utils'
-import { type CLIOptions, type Config, createKubb, isInputPath, type KubbHooks, logLevel as logLevelMap } from '@kubb/core'
+import {
+  type CLIOptions,
+  type Config,
+  createKubb,
+  type Diagnostic,
+  diagnosticCode,
+  Diagnostics,
+  isInputPath,
+  isProblemDiagnostic,
+  type KubbHooks,
+  logLevel as logLevelMap,
+  narrowDiagnostic,
+  type ProblemDiagnostic,
+  type ReporterName,
+} from '@kubb/core'
 import { version } from '../../../package.json'
 import { KUBB_NPM_PACKAGE_URL } from '../../constants.ts'
-import { setupLogger, type HookSinkFactory } from '../../loggers/utils.ts'
+import { setupReporters, type HookSinkFactory } from '../../loggers/utils.ts'
 import { buildTelemetryEvent, sendTelemetry } from '../../telemetry.ts'
 import { executeHooks, getConfigs, runHook, startWatcher } from './utils.ts'
 
@@ -118,16 +132,16 @@ async function runToolPass({
         command: toolConfig.command,
         args: hookArgs,
         commandWithArgs,
-        context: hooks,
+        hooks,
         stream,
         sink: { onLine, onStdout, onStderr },
       }).catch(() => {})
 
       await hookEndPromise
     } catch (caughtError) {
-      const err = toError(caughtError)
-      await hooks.emit('kubb:error', { error: err })
-      toolError = err
+      // Don't render here. The caller turns this into a coded diagnostic and emits it through
+      // `Diagnostics.emit`, so format/lint/hook failures render like every other diagnostic.
+      toolError = toError(caughtError)
     }
   }
 
@@ -159,7 +173,7 @@ async function generate(options: GenerateProps): Promise<boolean> {
 
   await hooks.emit('kubb:info', { message: config.name ? `Build generation ${styleText('bold', config.name)}` : 'Build generation', info: inputPath })
 
-  const { files, failedPlugins, pluginTimings, error, driver } = await kubb.safeBuild()
+  const { files, diagnostics, driver } = await kubb.safeBuild()
 
   await hooks.emit('kubb:info', { message: 'Load summary' })
 
@@ -168,34 +182,38 @@ async function generate(options: GenerateProps): Promise<boolean> {
   const reportTelemetry = (status: 'success' | 'failed') =>
     sendTelemetry(buildTelemetryEvent({ command: 'generate', kubbVersion: version, plugins: telemetryPlugins, hrStart, filesCreated: files.length, status }))
 
-  if (failedPlugins.size > 0 || error) {
-    const allErrors = [error, ...Array.from(failedPlugins, (it) => it.error)].filter(Boolean) as Array<Error>
-
-    for (const err of allErrors) {
-      await hooks.emit('kubb:error', { error: err })
+  // Render every problem, not just on failure, so warnings and info surface too.
+  // `performance` diagnostics feed the summary, not the log.
+  for (const diagnostic of diagnostics) {
+    if (!isProblemDiagnostic(diagnostic)) {
+      continue
+    }
+    const unknown = narrowDiagnostic(diagnostic, diagnosticCode.unknown)
+    if (unknown) {
+      await hooks.emit('kubb:error', { error: unknown.cause ?? new Error(unknown.message) })
+    } else {
+      await Diagnostics.emit(hooks, diagnostic)
     }
+  }
 
-    await hooks.emit('kubb:generation:end', { config, storage: kubb.storage })
-    await hooks.emit('kubb:generation:summary', {
-      config,
-      failedPlugins,
-      filesCreated: files.length,
-      status: 'failed',
-      hrStart,
-      pluginTimings: logLevel >= logLevelMap.verbose ? pluginTimings : undefined,
-    })
+  // Only an error-severity diagnostic fails the run. Warnings and info do not.
+  if (Diagnostics.hasError(diagnostics)) {
+    await hooks.emit('kubb:generation:end', { config, storage: kubb.storage, diagnostics, filesCreated: files.length, status: 'failed', hrStart })
 
     await reportTelemetry('failed')
     return false
   }
 
-  await hooks.emit('kubb:success', { message: 'Generation succeeded', info: inputPath })
-  await hooks.emit('kubb:generation:end', { config, storage: kubb.storage })
-
   const outputPath = path.resolve(config.root, config.output.path)
 
+  // The build succeeded. The formatter, linter, and post-generate hooks run after it. Their
+  // failures used to only emit `kubb:error`, so they never reached the summary, the json report,
+  // or the exit code. Collect them as coded diagnostics here.
+  const outputDiagnostics: Array<Diagnostic> = []
+
   const toolPasses = [
     config.output.format && {
+      code: diagnosticCode.formatFailed,
       toolValue: config.output.format,
       detect: detectFormatter,
       toolMap: formatters,
@@ -206,6 +224,7 @@ async function generate(options: GenerateProps): Promise<boolean> {
       onEnd: () => hooks.emit('kubb:format:end'),
     },
     config.output.lint && {
+      code: diagnosticCode.lintFailed,
       toolValue: config.output.lint,
       detect: detectLinter,
       toolMap: linters,
@@ -215,22 +234,73 @@ async function generate(options: GenerateProps): Promise<boolean> {
       onStart: () => hooks.emit('kubb:lint:start'),
       onEnd: () => hooks.emit('kubb:lint:end'),
     },
-  ].filter(Boolean) as Array<Omit<RunToolPassOptions, 'configName' | 'outputPath' | 'logLevel' | 'hooks'>>
+  ].filter(Boolean) as Array<{ code: ProblemDiagnostic['code'] } & Omit<RunToolPassOptions, 'configName' | 'outputPath' | 'logLevel' | 'hooks'>>
 
-  for (const pass of toolPasses) {
-    await runToolPass({ ...pass, configName: config.name, outputPath, logLevel, hooks, makeSink })
+  for (const { code, ...pass } of toolPasses) {
+    try {
+      await runToolPass({ ...pass, configName: config.name, outputPath, logLevel, hooks, makeSink })
+    } catch (caughtError) {
+      const diagnostic = outputDiagnostic(code, pass.toolLabel, caughtError)
+      outputDiagnostics.push(diagnostic)
+      await Diagnostics.emit(hooks, diagnostic)
+    }
   }
 
   if (config.hooks) {
     await hooks.emit('kubb:hooks:start')
-    await executeHooks({ configHooks: config.hooks, hooks, makeSink })
+    // `runHook` reports a failed `done` hook via `kubb:hook:end` rather than throwing, so listen
+    // for it across this pass and collect each failure.
+    const hookFailures: Array<Error> = []
+    const onHookEnd = (ctx: { success: boolean; error: Error | null }) => {
+      if (!ctx.success) hookFailures.push(ctx.error ?? new Error('Post-generate hook failed'))
+    }
+    hooks.on('kubb:hook:end', onHookEnd)
+    try {
+      await executeHooks({ configHooks: config.hooks, hooks, makeSink })
+    } finally {
+      hooks.off('kubb:hook:end', onHookEnd)
+    }
+    for (const error of hookFailures) {
+      const diagnostic = outputDiagnostic(diagnosticCode.hookFailed, 'Post-generate hook', error)
+      outputDiagnostics.push(diagnostic)
+      await Diagnostics.emit(hooks, diagnostic)
+    }
     await hooks.emit('kubb:hooks:end')
   }
 
-  await hooks.emit('kubb:generation:summary', { config, failedPlugins, filesCreated: files.length, status: 'success', hrStart, pluginTimings })
+  const finalDiagnostics = [...diagnostics, ...outputDiagnostics]
+  const failed = Diagnostics.hasError(outputDiagnostics)
+
+  if (!failed) {
+    await hooks.emit('kubb:success', { message: 'Generation succeeded', info: inputPath })
+  }
+
+  await hooks.emit('kubb:generation:end', {
+    config,
+    storage: kubb.storage,
+    diagnostics: finalDiagnostics,
+    filesCreated: files.length,
+    status: failed ? 'failed' : 'success',
+    hrStart,
+  })
 
-  await reportTelemetry('success')
-  return true
+  await reportTelemetry(failed ? 'failed' : 'success')
+  return !failed
+}
+
+/**
+ * Builds a coded diagnostic for an output-phase failure (formatter, linter, or `done` hook).
+ */
+function outputDiagnostic(code: ProblemDiagnostic['code'], label: string, caughtError: unknown): ProblemDiagnostic {
+  const error = toError(caughtError)
+  return {
+    code,
+    severity: 'error',
+    message: `${label} failed: ${error.message}`,
+    help: 'Check that the tool is installed and that the command and its config are correct.',
+    location: { kind: 'config' },
+    cause: error,
+  }
 }
 
 type GenerateCommandOptions = {
@@ -238,6 +308,7 @@ type GenerateCommandOptions = {
   configPath?: string
   logLevel: string
   watch: boolean
+  reporters?: Array<ReporterName>
 }
 
 async function checkForUpdate(hooks: AsyncEventEmitter<KubbHooks>): Promise<void> {
@@ -246,7 +317,7 @@ async function checkForUpdate(hooks: AsyncEventEmitter<KubbHooks>): Promise<void
       const res = await fetch(KUBB_NPM_PACKAGE_URL)
       const data = (await res.json()) as { version: string }
       if (data.version && version < data.version) {
-        await hooks.emit('kubb:version:new', { currentVersion: version, latestVersion: data.version })
+        await Diagnostics.emit(hooks, Diagnostics.update({ currentVersion: version, latestVersion: data.version }))
       }
     } catch {
       // Ignore network errors
@@ -256,29 +327,44 @@ async function checkForUpdate(hooks: AsyncEventEmitter<KubbHooks>): Promise<void
 
 /**
  * Runs the full Kubb generation lifecycle for the given CLI options.
- * Sets up the logger, checks for a newer version, loads configs, and calls `generate` for each config entry.
+ * Loads configs, sets up the selected reporters (CLI `--reporter` overrides `config.reporters`),
+ * checks for a newer version, and calls `generate` for each config entry.
  */
-export async function run({ input, configPath, logLevel: logLevelKey, watch }: GenerateCommandOptions): Promise<void> {
+export async function run({ input, configPath, logLevel: logLevelKey, watch, reporters: cliReporters }: GenerateCommandOptions): Promise<void> {
   const logLevel = logLevelMap[logLevelKey as keyof typeof logLevelMap] ?? logLevelMap.info
   const hooks = new AsyncEventEmitterClass<KubbHooks>()
 
-  const makeSink = await setupLogger(hooks, { logLevel })
-
-  await hooks.emit('kubb:lifecycle:start', { version })
-
-  await checkForUpdate(hooks)
-
+  // Load the config first so `config.reporters` can pick the reporters. A failure here has no
+  // reporter installed yet, so fall back to the default `cli` reporter to surface it.
+  let configs: Array<Config>
+  let resolvedConfigPath: string
   try {
-    await hooks.emit('kubb:config:start')
-
-    const { configs, configPath: resolvedConfigPath } = await getConfigs({
+    const loaded = await getConfigs({
       configPath,
       input,
       watch,
       logLevel: logLevelKey as CLIOptions['logLevel'],
     })
+    configs = loaded.configs
+    resolvedConfigPath = loaded.configPath
+  } catch (error) {
+    await setupReporters(hooks, { logLevel, reporters: ['cli'] })
+    await hooks.emit('kubb:error', { error: toError(error) })
+    process.exit(1)
+  }
+
+  // CLI `--reporter` wins. Otherwise the first config's `reporters`. Otherwise the default.
+  const reporters: Array<ReporterName> = cliReporters?.length ? cliReporters : (configs[0]?.reporters ?? ['cli'])
+  const makeSink = await setupReporters(hooks, { logLevel, reporters })
+
+  await hooks.emit('kubb:lifecycle:start', { version })
+
+  await checkForUpdate(hooks)
+
+  try {
     const relativeConfigPath = path.relative(process.cwd(), resolvedConfigPath)
 
+    await hooks.emit('kubb:config:start')
     await hooks.emit('kubb:info', { message: 'Config loaded', info: relativeConfigPath })
     await hooks.emit('kubb:success', { message: 'Config loaded successfully', info: relativeConfigPath })
     await hooks.emit('kubb:config:end', { configs })
@@ -289,7 +375,7 @@ export async function run({ input, configPath, logLevel: logLevelKey, watch }: G
         await startWatcher(
           [input || config.input.path],
           async (paths) => {
-            // Don't removeAll() — that would also drop logger and lifecycle listeners.
+            // Don't removeAll(), that would also drop logger and lifecycle listeners.
             // Plugin and middleware listeners are already disposed by safeBuild's
             // setupResult.dispose() in its finally block, so re-running generate()
             // on the same hooks emitter is safe.

package/src/runners/generate/utils.ts

@@ -135,7 +135,7 @@ export async function executeHooks({ configHooks, hooks, makeSink }: ExecuteHook
     await hooks.emit('kubb:hook:start', { id: hookId, command: cmd, args })
 
     const { stream = false, onLine, onStdout, onStderr } = makeSink?.(commandWithArgs, hookId) ?? {}
-    await runHook({ id: hookId, command: cmd, args, commandWithArgs, context: hooks, stream, sink: { onLine, onStdout, onStderr } })
+    await runHook({ id: hookId, command: cmd, args, commandWithArgs, hooks, stream, sink: { onLine, onStdout, onStderr } })
   }
 }
 
@@ -144,13 +144,13 @@ type RunHookOptions = {
   command: string
   args?: ReadonlyArray<string>
   commandWithArgs: string
-  context: AsyncEventEmitter<KubbHooks>
+  hooks: AsyncEventEmitter<KubbHooks>
   stream?: boolean
   sink?: HookSinkOptions
 }
 
-export async function runHook({ id, command, args, commandWithArgs, context, stream = false, sink }: RunHookOptions): Promise<void> {
-  const emitEnd = (success: boolean, error: Error | null) => context.emit('kubb:hook:end', { command, args, id, success, error })
+export async function runHook({ id, command, args, commandWithArgs, hooks, stream = false, sink }: RunHookOptions): Promise<void> {
+  const emitEnd = (success: boolean, error: Error | null) => hooks.emit('kubb:hook:end', { command, args, id, success, error })
 
   try {
     const proc = x(command, [...(args ?? [])], {
@@ -164,29 +164,26 @@ export async function runHook({ id, command, args, commandWithArgs, context, str
       }
     }
 
-    const result = await proc
-    await context.emit('kubb:debug', { date: new Date(), logs: [result.stdout.trimEnd()] })
-    await context.emit('kubb:success', { message: `${styleText('dim', commandWithArgs)} successfully executed` })
+    await proc
+    await hooks.emit('kubb:success', { message: `${styleText('dim', commandWithArgs)} successfully executed` })
     await emitEnd(true, null)
   } catch (err) {
     if (!(err instanceof NonZeroExitError)) {
       const error = toError(err)
       await emitEnd(false, error)
-      await context.emit('kubb:error', { error })
+      await hooks.emit('kubb:error', { error })
       return
     }
 
     const stderr = err.output?.stderr ?? ''
     const stdout = err.output?.stdout ?? ''
 
-    await context.emit('kubb:debug', { date: new Date(), logs: [stdout, stderr].filter(Boolean) })
-
     if (stderr) sink?.onStderr?.(stderr)
     if (stdout) sink?.onStdout?.(stdout)
 
     const error = new Error(`Hook execute failed: ${commandWithArgs}`)
     await emitEnd(false, error)
-    await context.emit('kubb:error', { error })
+    await hooks.emit('kubb:error', { error })
   }
 }
 

package/src/runners/init/run.ts

@@ -64,7 +64,7 @@ export async function run({ yes, version, input: inputFlag, output: outputFlag,
   }
 
   try {
-    // Check/create package.json — detect package manager once after the block
+    // Check/create package.json, detect package manager once after the block
     if (!hasPackageJson(cwd)) {
       if (!yes) {
         const shouldInit = await clack.confirm({

package/src/telemetry.ts

@@ -105,7 +105,7 @@ export type TelemetryPlugin = {
    */
   name: string
   /**
-   * anonymized plugin options snapshot — values are included but cannot be traced back to the user.
+   * anonymized plugin options snapshot, values are included but cannot be traced back to the user.
    */
   options: Record<string, unknown>
 }
@@ -246,7 +246,7 @@ export async function sendTelemetry(event: TelemetryEvent): Promise<void> {
         signal: AbortSignal.timeout(5_000),
       })
     } catch (_e) {
-      // Fail silently – telemetry must never break the CLI
+      // Fail silently, telemetry must never break the CLI
     }
   })
 }

package/dist/generate-DYPz-3vT.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"generate-DYPz-3vT.cjs","names":["defineCommand"],"sources":["../src/commands/generate.ts"],"sourcesContent":["import { defineCommand } from '@internals/utils'\n\nexport const command = defineCommand({\n  name: 'generate',\n  description:\n    '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.',\n  arguments: ['[input]'],\n  examples: ['kubb generate', 'kubb generate ./openapi.yaml', 'kubb generate --config kubb.config.ts', 'kubb generate --watch'],\n  options: {\n    config: {\n      type: 'string',\n      description: 'Path to the Kubb config',\n      short: 'c',\n    },\n    logLevel: {\n      type: 'string',\n      description: 'Info, silent, verbose or debug',\n      short: 'l',\n      default: 'info',\n      hint: 'silent|info|verbose|debug',\n      enum: ['silent', 'info', 'verbose', 'debug'],\n    },\n    watch: {\n      type: 'boolean',\n      description: 'Watch mode based on the input file',\n      short: 'w',\n      default: false,\n    },\n    debug: {\n      type: 'boolean',\n      description: 'Override logLevel to debug',\n      short: 'd',\n      default: false,\n    },\n    verbose: {\n      type: 'boolean',\n      description: 'Override logLevel to verbose',\n      short: 'v',\n      default: false,\n    },\n    silent: {\n      type: 'boolean',\n      description: 'Override logLevel to silent',\n      short: 's',\n      default: false,\n    },\n  },\n  async run({ values, positionals }) {\n    const logLevel = values.debug ? 'debug' : values.verbose ? 'verbose' : values.silent ? 'silent' : values.logLevel\n    const { run } = await import('../runners/generate/run.ts')\n\n    await run({\n      input: positionals[0],\n      configPath: values.config,\n      logLevel,\n      watch: values.watch,\n    })\n  },\n})\n"],"mappings":";;AAEA,MAAa,yCAAUA,EAAAA,cAAc;CACnC,MAAM;CACN,aACE;CACF,WAAW,CAAC,SAAS;CACrB,UAAU;EAAC;EAAiB;EAAgC;EAAyC;CAAuB;CAC5H,SAAS;EACP,QAAQ;GACN,MAAM;GACN,aAAa;GACb,OAAO;EACT;EACA,UAAU;GACR,MAAM;GACN,aAAa;GACb,OAAO;GACP,SAAS;GACT,MAAM;GACN,MAAM;IAAC;IAAU;IAAQ;IAAW;GAAO;EAC7C;EACA,OAAO;GACL,MAAM;GACN,aAAa;GACb,OAAO;GACP,SAAS;EACX;EACA,OAAO;GACL,MAAM;GACN,aAAa;GACb,OAAO;GACP,SAAS;EACX;EACA,SAAS;GACP,MAAM;GACN,aAAa;GACb,OAAO;GACP,SAAS;EACX;EACA,QAAQ;GACN,MAAM;GACN,aAAa;GACb,OAAO;GACP,SAAS;EACX;CACF;CACA,MAAM,IAAI,EAAE,QAAQ,eAAe;EACjC,MAAM,WAAW,OAAO,QAAQ,UAAU,OAAO,UAAU,YAAY,OAAO,SAAS,WAAW,OAAO;EACzG,MAAM,EAAE,QAAQ,MAAA,QAAA,QAAA,EAAA,WAAA,QAAM,oBAAA,CAAA;EAEtB,MAAM,IAAI;GACR,OAAO,YAAY;GACnB,YAAY,OAAO;GACnB;GACA,OAAO,OAAO;EAChB,CAAC;CACH;AACF,CAAC"}

package/dist/generate-DuzUhvOd.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"generate-DuzUhvOd.js","names":[],"sources":["../src/commands/generate.ts"],"sourcesContent":["import { defineCommand } from '@internals/utils'\n\nexport const command = defineCommand({\n  name: 'generate',\n  description:\n    '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.',\n  arguments: ['[input]'],\n  examples: ['kubb generate', 'kubb generate ./openapi.yaml', 'kubb generate --config kubb.config.ts', 'kubb generate --watch'],\n  options: {\n    config: {\n      type: 'string',\n      description: 'Path to the Kubb config',\n      short: 'c',\n    },\n    logLevel: {\n      type: 'string',\n      description: 'Info, silent, verbose or debug',\n      short: 'l',\n      default: 'info',\n      hint: 'silent|info|verbose|debug',\n      enum: ['silent', 'info', 'verbose', 'debug'],\n    },\n    watch: {\n      type: 'boolean',\n      description: 'Watch mode based on the input file',\n      short: 'w',\n      default: false,\n    },\n    debug: {\n      type: 'boolean',\n      description: 'Override logLevel to debug',\n      short: 'd',\n      default: false,\n    },\n    verbose: {\n      type: 'boolean',\n      description: 'Override logLevel to verbose',\n      short: 'v',\n      default: false,\n    },\n    silent: {\n      type: 'boolean',\n      description: 'Override logLevel to silent',\n      short: 's',\n      default: false,\n    },\n  },\n  async run({ values, positionals }) {\n    const logLevel = values.debug ? 'debug' : values.verbose ? 'verbose' : values.silent ? 'silent' : values.logLevel\n    const { run } = await import('../runners/generate/run.ts')\n\n    await run({\n      input: positionals[0],\n      configPath: values.config,\n      logLevel,\n      watch: values.watch,\n    })\n  },\n})\n"],"mappings":";;;AAEA,MAAa,UAAU,cAAc;CACnC,MAAM;CACN,aACE;CACF,WAAW,CAAC,SAAS;CACrB,UAAU;EAAC;EAAiB;EAAgC;EAAyC;CAAuB;CAC5H,SAAS;EACP,QAAQ;GACN,MAAM;GACN,aAAa;GACb,OAAO;EACT;EACA,UAAU;GACR,MAAM;GACN,aAAa;GACb,OAAO;GACP,SAAS;GACT,MAAM;GACN,MAAM;IAAC;IAAU;IAAQ;IAAW;GAAO;EAC7C;EACA,OAAO;GACL,MAAM;GACN,aAAa;GACb,OAAO;GACP,SAAS;EACX;EACA,OAAO;GACL,MAAM;GACN,aAAa;GACb,OAAO;GACP,SAAS;EACX;EACA,SAAS;GACP,MAAM;GACN,aAAa;GACb,OAAO;GACP,SAAS;EACX;EACA,QAAQ;GACN,MAAM;GACN,aAAa;GACb,OAAO;GACP,SAAS;EACX;CACF;CACA,MAAM,IAAI,EAAE,QAAQ,eAAe;EACjC,MAAM,WAAW,OAAO,QAAQ,UAAU,OAAO,UAAU,YAAY,OAAO,SAAS,WAAW,OAAO;EACzG,MAAM,EAAE,QAAQ,MAAM,OAAO;EAE7B,MAAM,IAAI;GACR,OAAO,YAAY;GACnB,YAAY,OAAO;GACnB;GACA,OAAO,OAAO;EAChB,CAAC;CACH;AACF,CAAC"}

package/dist/package-B0p9bKKV.js

@@ -1,6 +0,0 @@
-//#region package.json
-var version = "5.0.0-beta.35";
-//#endregion
-export { version as t };
-
-//# sourceMappingURL=package-B0p9bKKV.js.map

package/dist/package-B0p9bKKV.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"package-B0p9bKKV.js","names":[],"sources":["../package.json"],"sourcesContent":[""],"mappings":""}

package/dist/package-B121qOXj.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"package-B121qOXj.cjs","names":[],"sources":["../package.json"],"sourcesContent":[""],"mappings":""}