@reliverse/build 2.2.7

package/dist/impl/tsconfig-validator.js

@@ -0,0 +1,184 @@
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { logger } from "@reliverse/relinka";
+import { readTSConfig } from "@reliverse/typerso";
+export async function validateTSConfig(pkg, options = {}) {
+  const {
+    strict = false,
+    checkDeclarations = true,
+    checkBuildOutput = true
+  } = options;
+  const warnings = [];
+  const errors = [];
+  try {
+    const tsconfigPath = join(pkg.path, "tsconfig.json");
+    if (!existsSync(tsconfigPath)) {
+      if (pkg.hasTsConfig) {
+        warnings.push("tsconfig.json referenced but not found");
+      }
+      return { valid: true, warnings, errors };
+    }
+    const tsconfig = await readTSConfig(pkg.path);
+    if (!tsconfig) {
+      errors.push("Could not parse tsconfig.json");
+      return { valid: false, warnings, errors };
+    }
+    const compilerOptions = tsconfig.compilerOptions || {};
+    if (!tsconfig.compilerOptions) {
+      warnings.push("No compilerOptions found in tsconfig.json");
+    }
+    if (checkDeclarations) {
+      if (compilerOptions.declaration === false) {
+        warnings.push(
+          "declaration: false - TypeScript declaration files will not be generated"
+        );
+      } else if (compilerOptions.declaration === void 0) {
+        warnings.push(
+          "declaration not set - consider adding 'declaration: true' for library packages"
+        );
+      }
+      if (compilerOptions.emitDeclarationOnly === true && !compilerOptions.declaration) {
+        errors.push("emitDeclarationOnly: true requires declaration: true");
+      }
+      if (compilerOptions.declaration && !compilerOptions.outDir && !compilerOptions.declarationDir) {
+        warnings.push(
+          "declaration: true but no outDir or declarationDir specified - declarations will be emitted alongside source files"
+        );
+      }
+    }
+    if (checkBuildOutput) {
+      if (compilerOptions.outDir) {
+        const outDir = compilerOptions.outDir;
+        if (outDir.includes("src") || outDir.includes("source")) {
+          warnings.push(
+            `outDir '${outDir}' contains 'src' or 'source' - consider using 'dist' or 'build' for output directory`
+          );
+        }
+      } else {
+        warnings.push(
+          `No outDir specified - consider adding 'outDir: "dist"' for cleaner output structure`
+        );
+      }
+      if (compilerOptions.noEmit === true) {
+        warnings.push(
+          "noEmit: true - TypeScript will not emit any files (use for type checking only)"
+        );
+      }
+      if (compilerOptions.emitDeclarationOnly === true && compilerOptions.noEmit === true) {
+        errors.push("emitDeclarationOnly: true conflicts with noEmit: true");
+      }
+    }
+    if (compilerOptions.target && ![
+      "es2015",
+      "es2016",
+      "es2017",
+      "es2018",
+      "es2019",
+      "es2020",
+      "es2021",
+      "es2022",
+      "esnext"
+    ].includes(compilerOptions.target)) {
+      warnings.push(
+        `Unusual target '${compilerOptions.target}' - consider using a standard ES target`
+      );
+    }
+    if (compilerOptions.module && ![
+      "commonjs",
+      "amd",
+      "system",
+      "umd",
+      "es6",
+      "es2015",
+      "esnext",
+      "es2020",
+      "es2022",
+      "node16",
+      "nodenext"
+    ].includes(compilerOptions.module)) {
+      warnings.push(
+        `Unusual module '${compilerOptions.module}' - consider using 'esnext' or 'commonjs'`
+      );
+    }
+    if (!compilerOptions.strict) {
+      warnings.push(
+        "strict mode not enabled - consider adding 'strict: true' for better type safety"
+      );
+    }
+    if (!compilerOptions.skipLibCheck) {
+      warnings.push(
+        "skipLibCheck not set - consider adding 'skipLibCheck: true' for faster builds"
+      );
+    }
+    if (compilerOptions.allowJs === true && !compilerOptions.checkJs) {
+      warnings.push(
+        "allowJs: true without checkJs: true - JavaScript files will not be type-checked"
+      );
+    }
+    if (compilerOptions.experimentalDecorators === true && !compilerOptions.emitDecoratorMetadata) {
+      warnings.push(
+        "experimentalDecorators: true without emitDecoratorMetadata - decorator metadata will not be emitted"
+      );
+    }
+    if (pkg.isFrontendApp) {
+      if (compilerOptions.moduleResolution && !["node", "bundler"].includes(compilerOptions.moduleResolution)) {
+        warnings.push(
+          `Frontend app using moduleResolution '${compilerOptions.moduleResolution}' - consider using 'bundler' for modern bundlers`
+        );
+      }
+      if (compilerOptions.target && ["es5", "es2015"].includes(compilerOptions.target)) {
+        warnings.push(
+          `Frontend app using old target '${compilerOptions.target}' - consider using 'es2020' or newer for better performance`
+        );
+      }
+    }
+    if (!pkg.isFrontendApp) {
+      if (compilerOptions.moduleResolution && compilerOptions.moduleResolution === "bundler") {
+        warnings.push(
+          "Library using moduleResolution 'bundler' - consider using 'node' for better compatibility"
+        );
+      }
+      if (!compilerOptions.declaration) {
+        warnings.push(
+          "Library package without declaration: true - consider enabling for better type support"
+        );
+      }
+    }
+    const hasErrors = errors.length > 0;
+    const isValid = !hasErrors || !strict;
+    return { valid: isValid, warnings, errors };
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    errors.push(`Failed to validate tsconfig.json: ${errorMessage}`);
+    return { valid: false, warnings, errors };
+  }
+}
+export async function validateAllTSConfigs(packages, options = {}) {
+  const results = [];
+  let allValid = true;
+  for (const pkg of packages) {
+    const result = await validateTSConfig(pkg, options);
+    results.push({ package: pkg.name, result });
+    if (!result.valid) {
+      allValid = false;
+    }
+  }
+  return { valid: allValid, results };
+}
+export function logValidationResults(results, verbose = false) {
+  for (const { package: packageName, result } of results) {
+    if (result.errors.length > 0) {
+      logger.error(`\u274C ${packageName}: TSConfig validation failed`);
+      for (const error of result.errors) {
+        logger.error(`   ${error}`);
+      }
+    } else if (result.warnings.length > 0) {
+      logger.warn(`\u26A0\uFE0F  ${packageName}: TSConfig validation warnings`);
+      for (const warning of result.warnings) {
+        logger.warn(`   ${warning}`);
+      }
+    } else if (verbose) {
+      logger.success(`\u2705 ${packageName}: TSConfig validation passed`);
+    }
+  }
+}

package/dist/impl/type-guards.d.ts

@@ -0,0 +1,20 @@
+import type { PackageBuildConfig } from "@reliverse/config/impl/build";
+import type { BuildOptions, JSXOptions, MinifyOptions, NamingOptions } from "./types.js";
+export declare function isBuildOptions(obj: unknown): obj is BuildOptions;
+export declare function isPackageBuildConfig(obj: unknown): obj is PackageBuildConfig;
+export declare function isMinifyOptions(obj: unknown): obj is MinifyOptions;
+export declare function isJSXOptions(obj: unknown): obj is JSXOptions;
+export declare function isNamingOptions(obj: unknown): obj is NamingOptions;
+export declare function isValidTarget(target: unknown): target is "browser" | "bun" | "node";
+export declare function isValidFormat(format: unknown): format is "esm" | "cjs" | "iife";
+export declare function isValidSourcemap(sourcemap: unknown): sourcemap is "none" | "linked" | "inline" | "external";
+export declare function isValidLoader(loader: unknown): loader is "js";
+export declare function isValidEnv(env: unknown): env is "inline" | "disable" | `${string}*`;
+export declare function isValidPackages(packages: unknown): packages is "bundle" | "external";
+export declare function isStringArray(arr: unknown): arr is string[];
+export declare function isStringOrStringArray(value: unknown): value is string | string[];
+export declare function validateBuildConfig(config: unknown): {
+    valid: boolean;
+    errors: string[];
+};
+export declare function sanitizeBuildConfig(config: unknown): BuildOptions;

package/dist/impl/type-guards.js

@@ -0,0 +1,147 @@
+export function isBuildOptions(obj) {
+  return typeof obj === "object" && obj !== null;
+}
+export function isPackageBuildConfig(obj) {
+  return typeof obj === "object" && obj !== null;
+}
+export function isMinifyOptions(obj) {
+  if (typeof obj === "boolean") return true;
+  if (!obj || typeof obj !== "object") return false;
+  const opts = obj;
+  return opts.whitespace === void 0 || typeof opts.whitespace === "boolean" && opts.syntax === void 0 || typeof opts.syntax === "boolean" && opts.identifiers === void 0 || typeof opts.identifiers === "boolean";
+}
+export function isJSXOptions(obj) {
+  if (!obj || typeof obj !== "object") return false;
+  const opts = obj;
+  return opts.runtime === void 0 || (opts.runtime === "automatic" || opts.runtime === "classic") && opts.importSource === void 0 || typeof opts.importSource === "string";
+}
+export function isNamingOptions(obj) {
+  if (!obj || typeof obj !== "object") return false;
+  const opts = obj;
+  return opts.chunk === void 0 || typeof opts.chunk === "string" && opts.entry === void 0 || typeof opts.entry === "string" && opts.asset === void 0 || typeof opts.asset === "string";
+}
+export function isValidTarget(target) {
+  return target === "browser" || target === "bun" || target === "node";
+}
+export function isValidFormat(format) {
+  return format === "esm" || format === "cjs" || format === "iife";
+}
+export function isValidSourcemap(sourcemap) {
+  return sourcemap === "none" || sourcemap === "linked" || sourcemap === "inline" || sourcemap === "external";
+}
+export function isValidLoader(loader) {
+  const validLoaders = ["js"];
+  return typeof loader === "string" && validLoaders.includes(loader);
+}
+export function isValidEnv(env) {
+  if (typeof env !== "string") return false;
+  return env === "inline" || env === "disable" || env.endsWith("*");
+}
+export function isValidPackages(packages) {
+  return packages === "bundle" || packages === "external";
+}
+export function isStringArray(arr) {
+  return Array.isArray(arr) && arr.every((item) => typeof item === "string");
+}
+export function isStringOrStringArray(value) {
+  return typeof value === "string" || isStringArray(value);
+}
+export function validateBuildConfig(config) {
+  const errors = [];
+  if (!isBuildOptions(config)) {
+    errors.push("Invalid build configuration object");
+    return { valid: false, errors };
+  }
+  if (config.target && !isValidTarget(config.target)) {
+    errors.push(
+      `Invalid target: ${config.target}. Must be 'browser', 'bun', or 'node'`
+    );
+  }
+  if (config.format && !isValidFormat(config.format)) {
+    errors.push(
+      `Invalid format: ${config.format}. Must be 'esm', 'cjs', or 'iife'`
+    );
+  }
+  if (config.sourcemap && !isValidSourcemap(config.sourcemap)) {
+    errors.push(
+      `Invalid sourcemap: ${config.sourcemap}. Must be 'none', 'linked', 'inline', or 'external'`
+    );
+  }
+  if (config.minify && !isMinifyOptions(config.minify)) {
+    errors.push(
+      "Invalid minify options. Must be boolean or object with whitespace, syntax, identifiers properties"
+    );
+  }
+  if (config.jsx && !isJSXOptions(config.jsx)) {
+    errors.push(
+      "Invalid JSX options. Must have runtime (automatic|classic) and optional importSource (string)"
+    );
+  }
+  if (config.naming && !isNamingOptions(config.naming)) {
+    errors.push(
+      "Invalid naming options. Must have chunk, entry, asset properties as strings"
+    );
+  }
+  if (config.external && !isStringOrStringArray(config.external)) {
+    errors.push(
+      "Invalid external packages. Must be string or array of strings"
+    );
+  }
+  if (config.drop && !isStringArray(config.drop)) {
+    errors.push("Invalid drop patterns. Must be array of strings");
+  }
+  if (config.conditions && !isStringOrStringArray(config.conditions)) {
+    errors.push("Invalid conditions. Must be string or array of strings");
+  }
+  if (config.packages && !isValidPackages(config.packages)) {
+    errors.push(
+      `Invalid packages: ${config.packages}. Must be 'bundle' or 'external'`
+    );
+  }
+  if (config.env && !isValidEnv(config.env)) {
+    errors.push(
+      'Invalid env. Must be "inline", "disable", or string ending with "*"'
+    );
+  }
+  if (config.loader && typeof config.loader === "object") {
+    for (const [ext, loader] of Object.entries(config.loader)) {
+      if (!isValidLoader(loader)) {
+        errors.push(`Invalid loader for extension ${ext}: ${loader}`);
+      }
+    }
+  }
+  return { valid: errors.length === 0, errors };
+}
+export function sanitizeBuildConfig(config) {
+  const sanitized = {
+    ...config
+  };
+  if (sanitized.target && !isValidTarget(sanitized.target)) {
+    sanitized.target = "bun";
+  }
+  if (sanitized.format && !isValidFormat(sanitized.format)) {
+    sanitized.format = "esm";
+  }
+  if (sanitized.sourcemap && !isValidSourcemap(sanitized.sourcemap)) {
+    sanitized.sourcemap = "none";
+  }
+  if (sanitized.minify && !isMinifyOptions(sanitized.minify)) {
+    sanitized.minify = Boolean(sanitized.minify);
+  }
+  if (sanitized.external && !isStringOrStringArray(sanitized.external)) {
+    delete sanitized.external;
+  }
+  if (sanitized.drop && !isStringArray(sanitized.drop)) {
+    delete sanitized.drop;
+  }
+  if (sanitized.conditions && !isStringOrStringArray(sanitized.conditions)) {
+    delete sanitized.conditions;
+  }
+  if (sanitized.packages && !isValidPackages(sanitized.packages)) {
+    sanitized.packages = "bundle";
+  }
+  if (sanitized.env && !isValidEnv(sanitized.env)) {
+    sanitized.env = "disable";
+  }
+  return sanitized;
+}

package/dist/impl/types.d.ts

@@ -0,0 +1,322 @@
+import type { GoBuildOptions, PackageBuildConfig, PerformanceBudget } from "@reliverse/config/impl/build";
+import type { TSConfig } from "pkg-types";
+export interface PackageInfo {
+    name: string;
+    path: string;
+    hasTsConfig: boolean;
+    entryPoints: string[];
+    outputDir: string;
+    buildConfig?: PackageBuildConfig;
+    isFrontendApp?: boolean;
+    hasHtmlEntry?: boolean;
+    hasPublicDir?: boolean;
+    private?: boolean;
+    isCLI?: boolean;
+    hasGoFiles?: boolean;
+}
+export interface MinifyOptions {
+    whitespace?: boolean;
+    syntax?: boolean;
+    identifiers?: boolean;
+}
+export interface JSXOptions {
+    runtime?: "automatic" | "classic";
+    importSource?: string;
+}
+export interface NamingOptions {
+    chunk?: string;
+    entry?: string;
+    asset?: string;
+}
+export interface BuildResult {
+    package: PackageInfo;
+    success: boolean;
+    skipped: boolean;
+    output: string;
+    errors: string[];
+    warnings: string[];
+    buildTime: number;
+    bundleSize?: number;
+    cacheHit?: boolean;
+}
+export interface BuildSummary {
+    totalPackages: number;
+    failedPackages: number;
+    successfulPackages: number;
+    skippedPackages: number;
+    hasErrors: boolean;
+    results: BuildResult[];
+    totalBuildTime: number;
+    totalBundleSize: number;
+    cacheHits: number;
+}
+export interface BuildOptions {
+    concurrency?: number;
+    stopOnError?: boolean;
+    verbose?: boolean;
+    watch?: boolean;
+    bundler?: "bun" | "mkdist";
+    target?: "browser" | "bun" | "node";
+    format?: "esm" | "cjs" | "iife";
+    minify?: boolean | MinifyOptions;
+    minifyWhitespace?: boolean;
+    minifySyntax?: boolean;
+    minifyIdentifiers?: boolean;
+    sourcemap?: "none" | "linked" | "inline" | "external" | boolean;
+    splitting?: boolean;
+    external?: string | string[];
+    bytecode?: boolean;
+    drop?: string[];
+    packages?: "bundle" | "external";
+    publicPath?: string;
+    root?: string;
+    define?: Record<string, string>;
+    naming?: NamingOptions;
+    env?: "inline" | "disable" | `${string}*`;
+    banner?: string;
+    footer?: string;
+    conditions?: string[];
+    loader?: Record<string, BunLoaderType>;
+    ignoreDCEAnnotations?: boolean;
+    emitDCEAnnotations?: boolean;
+    throw?: boolean;
+    jsx?: JSXOptions;
+    keepNames?: boolean;
+    production?: boolean;
+    dev?: boolean;
+    compile?: boolean;
+    cache?: boolean;
+    noCache?: boolean;
+    entryNaming?: string;
+    chunkNaming?: string;
+    assetNaming?: string;
+    noBundle?: boolean;
+    reactFastRefresh?: boolean;
+    noClearScreen?: boolean;
+    windowsHideConsole?: boolean;
+    windowsIcon?: string;
+    windowsTitle?: string;
+    windowsPublisher?: string;
+    windowsVersion?: string;
+    windowsDescription?: string;
+    windowsCopyright?: string;
+    app?: boolean;
+    serverComponents?: boolean;
+    debugDumpServerFiles?: boolean;
+    debugNoMinify?: boolean;
+    html?: boolean | HtmlOptions;
+    assets?: AssetOptions;
+    devServer?: boolean | DevServerOptions;
+    cssChunking?: boolean;
+    port?: number;
+    open?: boolean;
+    publicAssets?: string;
+    debug?: boolean;
+    experimental?: string[];
+    macros?: boolean;
+    sideEffects?: boolean | string[];
+    bundleAnalyzer?: boolean;
+    typeCheck?: boolean;
+    generateTypes?: boolean;
+    bundleSizeLimit?: number;
+    performanceBudget?: PerformanceBudget;
+    imageOptimization?: boolean;
+    fontOptimization?: boolean;
+    cssOptimization?: boolean;
+    svgAsReact?: boolean;
+    cssModules?: boolean;
+    workerSupport?: boolean;
+    plugins?: string[];
+    performanceMonitoring?: boolean;
+    bundleAnalysis?: boolean;
+    maxConfigDepth?: number;
+    kind?: "library" | "cli" | "browser-app" | "native-app";
+    bin?: string;
+    validateTsconfig?: boolean;
+    strictTsconfig?: boolean;
+    dtsProvider?: "dts-bundle-generator" | "api-extractor" | "typescript";
+    go?: GoBuildOptions;
+    replaceExports?: boolean;
+    replaceExportsIgnorePackages?: string;
+    allowPrivateBuild?: string | string[];
+    filter?: string | string[];
+    goOnly?: boolean;
+    tsOnly?: boolean;
+}
+export interface CacheEntry {
+    hash: string;
+    timestamp: number;
+    buildTime: number;
+    bundleSize: number;
+    outputFiles: string[];
+}
+export interface CacheOptions {
+    enabled: boolean;
+    directory: string;
+    ttl: number;
+}
+export type BunLoaderType = "js" | "jsx" | "ts" | "tsx" | "json" | "toml" | "file" | "napi" | "wasm" | "text";
+export type Loader = MkdistLoader;
+export interface BunPlugin {
+    name: string;
+    setup: (build: unknown) => void;
+}
+export interface BuildArtifact {
+    path: string;
+    loader: Loader;
+    hash: string | null;
+    kind: "entry-point" | "chunk" | "asset" | "sourcemap" | "bytecode";
+    sourcemap: BuildArtifact | null;
+}
+export interface BuildMessage {
+    name: "BuildMessage";
+    position: Position | null;
+    code: string;
+    message: string;
+    level: "error" | "warning" | "info" | "debug" | "verbose";
+    toString(): string;
+}
+export interface ResolveMessage {
+    name: "ResolveMessage";
+    position: Position | null;
+    code: string;
+    message: string;
+    referrer: string;
+    specifier: string;
+    importKind: "entry_point" | "stmt" | "require" | "import" | "dynamic" | "require_resolve" | "at" | "at_conditional" | "url" | "internal";
+    level: "error" | "warning" | "info" | "debug" | "verbose";
+    toString(): string;
+}
+export interface Position {
+    file: string;
+    line: number;
+    column: number;
+}
+export interface HtmlOptions {
+    entryPoints?: string[];
+    inject?: boolean;
+    minify?: boolean;
+}
+export interface AssetOptions {
+    publicPath?: string;
+    copyFiles?: string[];
+    imageOptimization?: boolean;
+}
+export interface DevServerOptions {
+    port?: number;
+    host?: string;
+    hmr?: boolean;
+    open?: boolean;
+}
+export interface DlerPlugin {
+    name: string;
+    setup: (build: BunBuildConfig) => void;
+    onBuildStart?: () => void;
+    onBuildEnd?: (result: BuildResult, buildOptions?: BuildOptions) => void;
+    onResolve?: (args: unknown) => unknown;
+    onLoad?: (args: unknown) => unknown;
+}
+export interface CompileOptions {
+    windowsHideConsole?: boolean;
+    windowsIcon?: string;
+    windowsTitle?: string;
+    windowsPublisher?: string;
+    windowsVersion?: string;
+    windowsDescription?: string;
+    windowsCopyright?: string;
+}
+export interface BunBuildConfig {
+    entrypoints: string[];
+    outdir: string;
+    target?: "browser" | "bun" | "node";
+    format?: "esm" | "cjs" | "iife";
+    sourcemap?: "none" | "linked" | "inline" | "external" | boolean;
+    splitting?: boolean;
+    external?: string[];
+    bytecode?: boolean;
+    drop?: string[];
+    packages?: "bundle" | "external";
+    publicPath?: string;
+    root?: string;
+    define?: Record<string, string>;
+    naming?: NamingOptions;
+    env?: "inline" | "disable" | `${string}*`;
+    banner?: string;
+    footer?: string;
+    conditions?: string[];
+    loader?: Record<string, BunLoaderType>;
+    ignoreDCEAnnotations?: boolean;
+    emitDCEAnnotations?: boolean;
+    throw?: boolean;
+    jsx?: JSXOptions;
+    keepNames?: boolean;
+    minify?: boolean | MinifyOptions;
+    plugins?: BunPlugin[];
+    noBundle?: boolean;
+    reactFastRefresh?: boolean;
+    noClearScreen?: boolean;
+    windowsHideConsole?: boolean;
+    windowsIcon?: string;
+    windowsTitle?: string;
+    windowsPublisher?: string;
+    windowsVersion?: string;
+    windowsDescription?: string;
+    windowsCopyright?: string;
+    app?: boolean;
+    serverComponents?: boolean;
+    debugDumpServerFiles?: boolean;
+    debugNoMinify?: boolean;
+    compile?: CompileOptions | boolean;
+    verbose?: boolean;
+}
+export interface MkdistOptions {
+    srcDir: string;
+    distDir: string;
+    rootDir: string;
+    format?: "esm" | "cjs";
+    ext?: string;
+    pattern?: string;
+    cleanDist?: boolean;
+    addRelativeDeclarationExtensions?: boolean;
+    typescript?: {
+        compilerOptions?: TSConfig["compilerOptions"];
+    };
+    globOptions?: Record<string, unknown>;
+    verbose?: boolean;
+    [key: string]: unknown;
+}
+export interface InputFile {
+    path: string;
+    srcPath: string;
+    extension: string;
+    getContents: () => Promise<string>;
+}
+export interface MkdistInputFile extends InputFile {
+    srcPath: string;
+}
+export interface OutputFile {
+    path: string;
+    srcPath: string;
+    contents?: string;
+    extension?: string;
+    declaration?: boolean;
+    skip?: boolean;
+    raw?: boolean;
+    errors?: TypeError[];
+}
+export type LoaderName = "js";
+export interface CreateLoaderOptions {
+    loaders?: (LoaderName | Loader)[];
+    declaration?: boolean;
+    format?: "esm" | "cjs";
+    ext?: string;
+    esbuild?: Record<string, unknown>;
+    [key: string]: unknown;
+}
+export interface LoaderContext {
+    loadFile: LoadFile;
+    options: CreateLoaderOptions;
+}
+export type LoadFile = (input: InputFile) => Promise<OutputFile[] | undefined>;
+export type MkdistLoader = (input: InputFile, context: LoaderContext) => Promise<OutputFile[] | undefined>;
+export type LoaderResult = OutputFile[];

package/dist/impl/utils/go-build-handler.d.ts

@@ -0,0 +1,12 @@
+import type { BuildOptions, PackageInfo } from "../types.js";
+/**
+ * Handle Go build for a package if applicable
+ */
+export declare function handleGoBuild(pkg: PackageInfo, options: BuildOptions, verbose: boolean): Promise<void>;
+/**
+ * Handle Go-only build mode
+ */
+export declare function handleGoOnlyBuild(pkg: PackageInfo, options: BuildOptions): Promise<{
+    success: boolean;
+    errors: string[];
+}>;