craft-native 0.0.37 → 0.0.49

package/dist/cli.js

@@ -0,0 +1,4168 @@
+#!/usr/bin/env bun
+// @bun
+var __defProp = Object.defineProperty;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = import.meta.require;
+
+// src/package.ts
+var exports_package = {};
+__export(exports_package, {
+  windowsExecutableName: () => windowsExecutableName,
+  windowsArchitecture: () => windowsArchitecture,
+  shouldRetryHdiutil: () => shouldRetryHdiutil,
+  renderWixSource: () => renderWixSource,
+  productbuildArguments: () => productbuildArguments,
+  packageApp: () => packageApp,
+  pack: () => pack,
+  notarytoolArguments: () => notarytoolArguments,
+  macOSInfoPlist: () => macOSInfoPlist,
+  formatPackagingCommandError: () => formatPackagingCommandError,
+  dmgCreateArguments: () => dmgCreateArguments,
+  dmgCapacityMegabytes: () => dmgCapacityMegabytes,
+  codesignArguments: () => codesignArguments
+});
+import { spawn } from "child_process";
+import { createHash } from "crypto";
+import {
+  chmodSync,
+  copyFileSync,
+  cpSync,
+  existsSync as existsSync3,
+  lstatSync,
+  mkdirSync,
+  mkdtempSync,
+  readFileSync,
+  readdirSync,
+  rmSync,
+  writeFileSync
+} from "fs";
+import { homedir, tmpdir } from "os";
+import { basename, join } from "path";
+import { deflateRawSync } from "zlib";
+function crc32(data) {
+  let c = 4294967295;
+  for (let i = 0;i < data.length; i++)
+    c = CRC32_TABLE[(c ^ data[i]) & 255] ^ c >>> 8;
+  return (c ^ 4294967295) >>> 0;
+}
+function dosDateTime(d) {
+  const time = d.getHours() << 11 | d.getMinutes() << 5 | d.getSeconds() >> 1;
+  const date = d.getFullYear() - 1980 << 9 | d.getMonth() + 1 << 5 | d.getDate();
+  return { time: time & 65535, date: date & 65535 };
+}
+function buildZip(entries) {
+  const { time, date } = dosDateTime(new Date);
+  const locals = [];
+  const central = [];
+  let offset = 0;
+  for (const entry of entries) {
+    const nameBytes = Buffer.from(entry.name, "utf8");
+    const compressed = deflateRawSync(entry.data, { level: 9 });
+    const crc = crc32(entry.data);
+    const lfh = Buffer.alloc(30);
+    lfh.writeUInt32LE(67324752, 0);
+    lfh.writeUInt16LE(20, 4);
+    lfh.writeUInt16LE(0, 6);
+    lfh.writeUInt16LE(8, 8);
+    lfh.writeUInt16LE(time, 10);
+    lfh.writeUInt16LE(date, 12);
+    lfh.writeUInt32LE(crc, 14);
+    lfh.writeUInt32LE(compressed.length, 18);
+    lfh.writeUInt32LE(entry.data.length, 22);
+    lfh.writeUInt16LE(nameBytes.length, 26);
+    lfh.writeUInt16LE(0, 28);
+    locals.push(lfh, nameBytes, compressed);
+    const cdh = Buffer.alloc(46);
+    cdh.writeUInt32LE(33639248, 0);
+    cdh.writeUInt16LE(20, 4);
+    cdh.writeUInt16LE(20, 6);
+    cdh.writeUInt16LE(0, 8);
+    cdh.writeUInt16LE(8, 10);
+    cdh.writeUInt16LE(time, 12);
+    cdh.writeUInt16LE(date, 14);
+    cdh.writeUInt32LE(crc, 16);
+    cdh.writeUInt32LE(compressed.length, 20);
+    cdh.writeUInt32LE(entry.data.length, 24);
+    cdh.writeUInt16LE(nameBytes.length, 28);
+    cdh.writeUInt16LE(0, 30);
+    cdh.writeUInt16LE(0, 32);
+    cdh.writeUInt16LE(0, 34);
+    cdh.writeUInt16LE(0, 36);
+    cdh.writeUInt32LE(0, 38);
+    cdh.writeUInt32LE(offset, 42);
+    central.push(cdh, nameBytes);
+    offset += lfh.length + nameBytes.length + compressed.length;
+  }
+  const centralBuf = Buffer.concat(central);
+  const eocd = Buffer.alloc(22);
+  eocd.writeUInt32LE(101010256, 0);
+  eocd.writeUInt16LE(0, 4);
+  eocd.writeUInt16LE(0, 6);
+  eocd.writeUInt16LE(entries.length, 8);
+  eocd.writeUInt16LE(entries.length, 10);
+  eocd.writeUInt32LE(centralBuf.length, 12);
+  eocd.writeUInt32LE(offset, 16);
+  eocd.writeUInt16LE(0, 20);
+  return Buffer.concat([...locals, centralBuf, eocd]);
+}
+function formatPackagingCommandError(tool, code, stdout3, stderr) {
+  const detail = `${stdout3}${stderr}`.trim();
+  return `${tool} exited with code ${code}${detail ? `: ${detail}` : ""}`;
+}
+async function packageApp(config) {
+  const results = [];
+  if (!config.binaryPath || !existsSync3(config.binaryPath)) {
+    throw new Error(`Binary not found: ${config.binaryPath}`);
+  }
+  const platforms = config.platforms || [detectPlatform()];
+  const outDir = config.outDir || join(process.cwd(), "dist");
+  if (!existsSync3(outDir)) {
+    mkdirSync(outDir, { recursive: true });
+  }
+  for (const platform of platforms) {
+    switch (platform) {
+      case "macos":
+        results.push(...await packageMacOS(config, outDir));
+        break;
+      case "windows":
+        results.push(...await packageWindows(config, outDir));
+        break;
+      case "linux":
+        results.push(...await packageLinux(config, outDir));
+        break;
+    }
+  }
+  return results;
+}
+async function packageMacOS(config, outDir) {
+  const results = [];
+  const { name, version: version2, bundleId = `com.myapp.${name.toLowerCase()}` } = config;
+  const opts = config.macos || {};
+  const hardenedRuntime = !opts.appStore;
+  const appBundlePath = join(outDir, `${name}.app`);
+  const appBundle = createMacOSAppBundle({
+    name,
+    version: version2,
+    bundleId,
+    buildNumber: opts.buildNumber,
+    category: opts.category,
+    minimumSystemVersion: opts.minimumSystemVersion,
+    menuBarOnly: opts.menuBarOnly,
+    binaryPath: config.binaryPath,
+    iconPath: config.iconPath,
+    provisioningProfile: opts.provisioningProfile,
+    additionalExecutables: opts.additionalExecutables,
+    outputPath: appBundlePath
+  });
+  if (!appBundle.success) {
+    results.push({
+      success: false,
+      platform: "macos",
+      format: "app",
+      error: appBundle.error
+    });
+    return results;
+  }
+  if (opts.signIdentity) {
+    const signed = await runTool("codesign", codesignArguments({
+      path: appBundlePath,
+      identity: opts.signIdentity,
+      entitlements: opts.entitlements,
+      hardenedRuntime
+    }));
+    if (!signed.success) {
+      results.push({ success: false, platform: "macos", format: "app", error: signed.error });
+      return results;
+    }
+  } else if (opts.appStore) {
+    results.push({
+      success: false,
+      platform: "macos",
+      format: "pkg",
+      error: 'App Store packaging requires macos.signIdentity (a "3rd Party Mac Developer Application" identity)'
+    });
+    return results;
+  }
+  results.push({ success: true, platform: "macos", format: "app", outputPath: appBundlePath });
+  if (opts.dmg !== false) {
+    const outputPath = join(outDir, `${name}-${version2}.dmg`);
+    const dmgResult = await createDMG({ appBundlePath, outputPath, volumeName: name });
+    results.push({
+      success: dmgResult.success,
+      platform: "macos",
+      format: "dmg",
+      outputPath: dmgResult.outputPath,
+      error: dmgResult.error
+    });
+    if (dmgResult.success)
+      results.push(...await notarizeIfRequested(opts, outputPath, "dmg"));
+  }
+  if (opts.pkg || opts.appStore) {
+    const outputPath = join(outDir, `${name}-${version2}.pkg`);
+    const pkgResult = await createPKG({
+      appBundlePath,
+      outputPath,
+      identifier: bundleId,
+      version: version2,
+      appStore: opts.appStore === true,
+      installerIdentity: opts.installerIdentity
+    });
+    results.push({
+      success: pkgResult.success,
+      platform: "macos",
+      format: opts.appStore ? "pkg (app store)" : "pkg",
+      outputPath: pkgResult.outputPath,
+      error: pkgResult.error
+    });
+    if (pkgResult.success && !opts.appStore)
+      results.push(...await notarizeIfRequested(opts, outputPath, "pkg"));
+  }
+  return results;
+}
+async function notarizeIfRequested(opts, artifactPath, format) {
+  if (!opts.notarize)
+    return [];
+  if (!opts.appleId || !opts.applePassword || !opts.teamId) {
+    return [{
+      success: false,
+      platform: "macos",
+      format: `${format} (notarize)`,
+      error: "Notarization requires macos.appleId, macos.applePassword and macos.teamId"
+    }];
+  }
+  const submitted = await runTool("xcrun", notarytoolArguments({
+    artifactPath,
+    appleId: opts.appleId,
+    applePassword: opts.applePassword,
+    teamId: opts.teamId
+  }));
+  if (!submitted.success)
+    return [{ success: false, platform: "macos", format: `${format} (notarize)`, error: submitted.error }];
+  const stapled = await runTool("xcrun", ["stapler", "staple", artifactPath]);
+  return [{
+    success: stapled.success,
+    platform: "macos",
+    format: `${format} (notarize)`,
+    outputPath: stapled.success ? artifactPath : undefined,
+    error: stapled.success ? undefined : stapled.error
+  }];
+}
+async function packageWindows(config, outDir) {
+  const results = [];
+  const { name, version: version2 } = config;
+  const opts = config.windows || {};
+  if (opts.msi !== false) {
+    const msiResult = await createMSI({
+      name,
+      version: version2,
+      binaryPath: config.binaryPath,
+      outputPath: join(outDir, `${name}-${version2}.msi`),
+      manufacturer: config.author || "Unknown",
+      architecture: opts.architecture || windowsArchitecture(process.arch),
+      certificatePath: opts.certificatePath,
+      certificatePassword: opts.certificatePassword
+    });
+    results.push({
+      success: msiResult.success,
+      platform: "windows",
+      format: "msi",
+      outputPath: msiResult.outputPath,
+      error: msiResult.error
+    });
+  }
+  if (opts.zip || opts.msi === false) {
+    const zipResult = await createZIP({
+      name,
+      version: version2,
+      binaryPath: config.binaryPath,
+      outputPath: join(outDir, `${name}-${version2}-windows.zip`)
+    });
+    results.push({
+      success: zipResult.success,
+      platform: "windows",
+      format: "zip",
+      outputPath: zipResult.outputPath,
+      error: zipResult.error
+    });
+  }
+  return results;
+}
+async function packageLinux(config, outDir) {
+  const results = [];
+  const { name, version: version2 } = config;
+  const opts = config.linux || {};
+  if (opts.deb !== false) {
+    const debResult = await createDEB({
+      name,
+      version: version2,
+      binaryPath: config.binaryPath,
+      outputPath: join(outDir, `${name}_${version2}_amd64.deb`),
+      description: config.description || "",
+      maintainer: config.author || "Unknown",
+      dependencies: opts.debDependencies || ["libgtk-3-0", "libwebkit2gtk-4.1-37"]
+    });
+    results.push({
+      success: debResult.success,
+      platform: "linux",
+      format: "deb",
+      outputPath: debResult.outputPath,
+      error: debResult.error
+    });
+  }
+  if (opts.rpm) {
+    const rpmResult = await createRPM({
+      name,
+      version: version2,
+      binaryPath: config.binaryPath,
+      outputPath: join(outDir, `${name}-${version2}-1.x86_64.rpm`),
+      description: config.description || "",
+      requires: opts.rpmDependencies || ["gtk3", "webkit2gtk3"]
+    });
+    results.push({
+      success: rpmResult.success,
+      platform: "linux",
+      format: "rpm",
+      outputPath: rpmResult.outputPath,
+      error: rpmResult.error
+    });
+  }
+  if (opts.appImage) {
+    const appImageResult = await createAppImage({
+      name,
+      version: version2,
+      binaryPath: config.binaryPath,
+      outputPath: join(outDir, `${name}-${version2}-x86_64.AppImage`),
+      iconPath: config.iconPath
+    });
+    results.push({
+      success: appImageResult.success,
+      platform: "linux",
+      format: "appimage",
+      outputPath: appImageResult.outputPath,
+      error: appImageResult.error
+    });
+  }
+  return results;
+}
+function macOSInfoPlist(metadata) {
+  const entries = [
+    ["CFBundleExecutable", metadata.name],
+    ["CFBundleIdentifier", metadata.bundleId],
+    ["CFBundleName", metadata.name],
+    ["CFBundleShortVersionString", metadata.version],
+    ["CFBundleVersion", metadata.buildNumber || metadata.version],
+    ["CFBundlePackageType", "APPL"],
+    ["NSHighResolutionCapable", true]
+  ];
+  if (metadata.iconName)
+    entries.push(["CFBundleIconFile", metadata.iconName]);
+  if (metadata.category)
+    entries.push(["LSApplicationCategoryType", metadata.category]);
+  if (metadata.minimumSystemVersion)
+    entries.push(["LSMinimumSystemVersion", metadata.minimumSystemVersion]);
+  if (metadata.menuBarOnly)
+    entries.push(["LSUIElement", true]);
+  const body = entries.map(([key, value]) => `    <key>${xml(key)}</key>
+${value === true ? "    <true/>" : `    <string>${xml(value)}</string>`}`).join(`
+`);
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+${body}
+</dict>
+</plist>`;
+}
+function codesignArguments(opts) {
+  return [
+    "--force",
+    "--sign",
+    opts.identity,
+    "--timestamp",
+    ...opts.hardenedRuntime ? ["--options", "runtime"] : [],
+    ...opts.entitlements ? ["--entitlements", opts.entitlements] : [],
+    "--deep",
+    opts.path
+  ];
+}
+function productbuildArguments(opts) {
+  return [
+    "--component",
+    opts.appBundlePath,
+    "/Applications",
+    "--sign",
+    opts.identity,
+    opts.outputPath
+  ];
+}
+function notarytoolArguments(opts) {
+  return [
+    "notarytool",
+    "submit",
+    opts.artifactPath,
+    "--apple-id",
+    opts.appleId,
+    "--password",
+    opts.applePassword,
+    "--team-id",
+    opts.teamId,
+    "--wait"
+  ];
+}
+function createMacOSAppBundle(opts) {
+  try {
+    const { name, binaryPath, iconPath, provisioningProfile, additionalExecutables, outputPath } = opts;
+    const contents = join(outputPath, "Contents");
+    const macOS = join(contents, "MacOS");
+    mkdirSync(macOS, { recursive: true });
+    mkdirSync(join(contents, "Resources"), { recursive: true });
+    copyFileSync(binaryPath, join(macOS, name));
+    chmodSync(join(macOS, name), 493);
+    for (const executable of additionalExecutables || []) {
+      if (!existsSync3(executable))
+        return { success: false, error: `Additional executable not found: ${executable}` };
+      const destination = join(macOS, basename(executable));
+      copyFileSync(executable, destination);
+      chmodSync(destination, 493);
+    }
+    let iconName;
+    if (iconPath) {
+      if (!existsSync3(iconPath))
+        return { success: false, error: `Icon not found: ${iconPath}` };
+      iconName = basename(iconPath).replace(/\.icns$/i, "");
+      copyFileSync(iconPath, join(contents, "Resources", `${iconName}.icns`));
+    }
+    if (provisioningProfile) {
+      if (!existsSync3(provisioningProfile))
+        return { success: false, error: `Provisioning profile not found: ${provisioningProfile}` };
+      copyFileSync(provisioningProfile, join(contents, "embedded.provisionprofile"));
+    }
+    writeFileSync(join(contents, "Info.plist"), macOSInfoPlist({ ...opts, iconName }));
+    return { success: true };
+  } catch (error) {
+    return { success: false, error: error.message };
+  }
+}
+function pathContentBytes(path2) {
+  const stat = lstatSync(path2);
+  if (!stat.isDirectory())
+    return stat.size;
+  return readdirSync(path2).reduce((total, entry) => total + pathContentBytes(join(path2, entry)), 0);
+}
+function dmgCapacityMegabytes(contentBytes) {
+  if (!Number.isSafeInteger(contentBytes) || contentBytes < 0)
+    throw new Error(`DMG content size must be a non-negative safe integer: ${contentBytes}`);
+  const contentMegabytes = Math.ceil(contentBytes / MEBIBYTE);
+  return Math.max(64, Math.ceil(contentMegabytes * 1.25) + 32);
+}
+function dmgCreateArguments(opts, contentBytes) {
+  return [
+    "create",
+    "-volname",
+    opts.volumeName,
+    "-srcfolder",
+    opts.appBundlePath,
+    "-size",
+    `${dmgCapacityMegabytes(contentBytes)}m`,
+    "-ov",
+    "-format",
+    "UDZO",
+    opts.outputPath
+  ];
+}
+function shouldRetryHdiutil(error, attempt, maxAttempts = HDIUTIL_MAX_ATTEMPTS) {
+  if (!Number.isInteger(attempt) || attempt < 1 || !Number.isInteger(maxAttempts) || maxAttempts < 1)
+    throw new Error("hdiutil retry attempts must be positive integers");
+  return attempt < maxAttempts && /(?:resource busy|resource temporarily unavailable)/i.test(error);
+}
+function runTool(tool, args) {
+  return new Promise((resolve) => {
+    const proc = spawn(tool, args);
+    let stdout3 = "";
+    let stderr = "";
+    proc.stdout?.on("data", (chunk) => {
+      stdout3 += chunk.toString();
+    });
+    proc.stderr?.on("data", (chunk) => {
+      stderr += chunk.toString();
+    });
+    proc.on("close", (code) => {
+      if (code === 0)
+        resolve({ success: true });
+      else
+        resolve({ success: false, error: formatPackagingCommandError(tool, code, stdout3, stderr) });
+    });
+    proc.on("error", (err) => resolve({ success: false, error: err.message }));
+  });
+}
+async function createDMG(opts) {
+  if (!/^[^/:\n]{1,27}$/.test(opts.volumeName))
+    return { success: false, error: `Invalid DMG volume name "${opts.volumeName}"; must be 1..27 chars without /, :, or newline` };
+  const args = dmgCreateArguments(opts, pathContentBytes(opts.appBundlePath));
+  const failures = [];
+  for (let attempt = 1;attempt <= HDIUTIL_MAX_ATTEMPTS; attempt++) {
+    const result = await runHdiutil(args);
+    if (result.success)
+      return { success: true, outputPath: opts.outputPath };
+    failures.push(`attempt ${attempt}: ${result.error}`);
+    if (!shouldRetryHdiutil(result.error, attempt))
+      return { success: false, error: failures.join(`
+`) };
+    rmSync(opts.outputPath, { force: true });
+    await new Promise((resolve) => setTimeout(resolve, attempt * 2000));
+  }
+  return { success: false, error: failures.join(`
+`) };
+}
+async function createPKG(opts) {
+  if (!/^[a-zA-Z0-9._-]+$/.test(opts.identifier) || !opts.identifier.includes("."))
+    return { success: false, error: `Invalid pkg identifier "${opts.identifier}"; expected reverse-DNS like com.example.app` };
+  if (!/^[A-Za-z0-9._+-]+$/.test(opts.version))
+    return { success: false, error: `Invalid pkg version "${opts.version}"` };
+  if (opts.appStore) {
+    if (!opts.installerIdentity)
+      return { success: false, error: 'App Store packaging requires macos.installerIdentity (a "3rd Party Mac Developer Installer" identity)' };
+    const built = await runTool("productbuild", productbuildArguments({
+      appBundlePath: opts.appBundlePath,
+      outputPath: opts.outputPath,
+      identity: opts.installerIdentity
+    }));
+    return built.success ? { success: true, outputPath: opts.outputPath } : { success: false, error: built.error };
+  }
+  const tempDir = mkdtempSync(join(tmpdir(), "craft-pkg-"));
+  try {
+    const appsDir = join(tempDir, "Applications");
+    mkdirSync(appsDir, { recursive: true });
+    cpSync(opts.appBundlePath, join(appsDir, basename(opts.appBundlePath)), { recursive: true });
+    const built = await runTool("pkgbuild", [
+      "--root",
+      tempDir,
+      "--identifier",
+      opts.identifier,
+      "--version",
+      opts.version,
+      "--install-location",
+      "/",
+      ...opts.installerIdentity ? ["--sign", opts.installerIdentity] : [],
+      opts.outputPath
+    ]);
+    return built.success ? { success: true, outputPath: opts.outputPath } : { success: false, error: built.error };
+  } finally {
+    rmSync(tempDir, { recursive: true, force: true });
+  }
+}
+function xml(value) {
+  return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;").replaceAll(`'`, "&apos;");
+}
+function wixIdentifier(value) {
+  const sanitized = value.replace(/[^A-Za-z0-9_.]/g, "_");
+  return /^[A-Za-z_]/.test(sanitized) ? sanitized : `_${sanitized}`;
+}
+function deterministicGuid(value) {
+  const digest = createHash("sha256").update(value).digest("hex").slice(0, 32).split("");
+  digest[12] = "4";
+  digest[16] = (Number.parseInt(digest[16], 16) & 3 | 8).toString(16);
+  const hex = digest.join("").toUpperCase();
+  return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+}
+function windowsArchitecture(architecture) {
+  if (architecture === "ia32" || architecture === "x86")
+    return "x86";
+  if (architecture === "x64" || architecture === "arm64")
+    return architecture;
+  throw new Error(`Unsupported Windows package architecture: ${architecture}`);
+}
+function renderWixSource(opts, sourceName) {
+  if (!/^[0-9]+\.[0-9]+\.[0-9]+(?:\.[0-9]+)?$/.test(opts.version))
+    throw new Error(`MSI version must have 3 or 4 numeric parts: ${opts.version}`);
+  const id = wixIdentifier(opts.name);
+  const manufacturer = opts.manufacturer.trim() || "Unknown";
+  const upgradeCode = deterministicGuid(`${manufacturer}/${opts.name}`);
+  const programFilesFolder = opts.architecture === "x86" ? "ProgramFilesFolder" : "ProgramFiles64Folder";
+  const win64 = opts.architecture === "x86" ? "no" : "yes";
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<Wix xmlns="http://schemas.microsoft.com/wix/2006/wi">
+  <Product Id="*" Name="${xml(opts.name)}" Language="1033" Version="${opts.version}" Manufacturer="${xml(manufacturer)}" UpgradeCode="${upgradeCode}">
+    <Package InstallerVersion="500" Compressed="yes" InstallScope="perMachine" Platform="${opts.architecture}" />
+    <MajorUpgrade AllowDowngrades="yes" />
+    <MediaTemplate EmbedCab="yes" />
+    <Directory Id="TARGETDIR" Name="SourceDir">
+      <Directory Id="${programFilesFolder}">
+        <Directory Id="INSTALLFOLDER" Name="${xml(opts.name)}">
+          <Component Id="${id}Executable" Guid="*" Win64="${win64}">
+            <File Id="${id}File" Source="${xml(sourceName)}" KeyPath="yes" />
+          </Component>
+        </Directory>
+      </Directory>
+    </Directory>
+    <Feature Id="ProductFeature" Title="${xml(opts.name)}" Level="1">
+      <ComponentRef Id="${id}Executable" />
+    </Feature>
+  </Product>
+</Wix>
+`;
+}
+function windowsExecutableName(name) {
+  if (name.length === 0 || name.trim() !== name || /[<>:"/\\|?*\u0000-\u001F]/.test(name) || /[. ]$/.test(name))
+    throw new Error(`Invalid Windows application name: ${JSON.stringify(name)}`);
+  if (/^(?:CON|PRN|AUX|NUL|COM[1-9]|LPT[1-9])(?:\.|$)/i.test(name))
+    throw new Error(`Reserved Windows application name: ${JSON.stringify(name)}`);
+  return `${name}.exe`;
+}
+function runCommand(command, args, cwd) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(command, args, { cwd, stdio: "inherit", windowsHide: true });
+    child.once("error", reject);
+    child.once("close", (code) => code === 0 ? resolve() : reject(new Error(`${command} exited with code ${code}`)));
+  });
+}
+async function createMSI(opts) {
+  const tempDir = mkdtempSync(join(tmpdir(), "craft-msi-"));
+  try {
+    const binaryName = windowsExecutableName(opts.name);
+    const sourcePath = join(tempDir, binaryName);
+    const wxsPath = join(tempDir, "installer.wxs");
+    const wixobjPath = join(tempDir, "installer.wixobj");
+    copyFileSync(opts.binaryPath, sourcePath);
+    writeFileSync(wxsPath, renderWixSource(opts, binaryName));
+    await runCommand("candle.exe", ["-nologo", "-out", wixobjPath, wxsPath], tempDir);
+    await runCommand("light.exe", ["-nologo", "-sval", "-out", opts.outputPath, wixobjPath], tempDir);
+    if (opts.certificatePath) {
+      const signArgs = ["sign", "/fd", "sha256", "/tr", "https://timestamp.digicert.com", "/td", "sha256", "/f", opts.certificatePath];
+      if (opts.certificatePassword)
+        signArgs.push("/p", opts.certificatePassword);
+      signArgs.push(opts.outputPath);
+      await runCommand("signtool.exe", signArgs);
+      await runCommand("signtool.exe", ["verify", "/pa", "/all", opts.outputPath]);
+    }
+    return { success: true, outputPath: opts.outputPath };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    const missingTool = /ENOENT|not found/i.test(message);
+    return { success: false, error: missingTool ? `WiX Toolset not found: ${message}` : message };
+  } finally {
+    rmSync(tempDir, { recursive: true, force: true });
+  }
+}
+async function createZIP(opts) {
+  try {
+    const data = new Uint8Array(readFileSync(opts.binaryPath));
+    const zip = buildZip([{ name: `${opts.name}.exe`, data }]);
+    writeFileSync(opts.outputPath, zip);
+    return { success: true, outputPath: opts.outputPath };
+  } catch (err) {
+    return { success: false, error: `Failed to write ZIP: ${err.message}` };
+  }
+}
+async function createDEB(opts) {
+  return new Promise((resolve) => {
+    try {
+      const sanitizedName = opts.name.toLowerCase();
+      const safeDebName = /^[a-z0-9._+-]+$/;
+      const safeVersion = /^[A-Za-z0-9._+-]+$/;
+      if (!safeDebName.test(sanitizedName)) {
+        resolve({ success: false, error: `DEB package name must match ${safeDebName} (got: ${sanitizedName})` });
+        return;
+      }
+      if (!safeVersion.test(opts.version)) {
+        resolve({ success: false, error: `DEB version must match ${safeVersion} (got: ${opts.version})` });
+        return;
+      }
+      const cleanLine = (s) => s.replace(/[\r\n]+/g, " ").trim();
+      const description = cleanLine(opts.description);
+      const maintainer = cleanLine(opts.maintainer);
+      for (const dep of opts.dependencies) {
+        if (!/^[a-z0-9._+-]+(?:\s*\([^)\n,]+\))?$/i.test(dep)) {
+          resolve({ success: false, error: `Invalid DEB dependency "${dep}"` });
+          return;
+        }
+      }
+      const tempDir = mkdtempSync(join(tmpdir(), "craft-deb-"));
+      const debianDir = join(tempDir, "DEBIAN");
+      const binDir = join(tempDir, "usr", "bin");
+      const applicationsDir = join(tempDir, "usr", "share", "applications");
+      mkdirSync(debianDir, { recursive: true });
+      mkdirSync(binDir, { recursive: true });
+      mkdirSync(applicationsDir, { recursive: true });
+      const binaryName = sanitizedName;
+      copyFileSync(opts.binaryPath, join(binDir, binaryName));
+      chmodSync(join(binDir, binaryName), 493);
+      const controlContent = `Package: ${sanitizedName}
+Version: ${opts.version}
+Section: utils
+Priority: optional
+Architecture: amd64
+Depends: ${opts.dependencies.join(", ")}
+Maintainer: ${maintainer}
+Description: ${description || opts.name}
+`;
+      writeFileSync(join(debianDir, "control"), controlContent);
+      const desktopContent = `[Desktop Entry]
+Type=Application
+Name=${opts.name}
+Exec=/usr/bin/${binaryName}
+Terminal=false
+Categories=Utility;
+`;
+      writeFileSync(join(applicationsDir, `${binaryName}.desktop`), desktopContent);
+      const proc = spawn("dpkg-deb", ["--build", tempDir, opts.outputPath]);
+      proc.on("close", (code) => {
+        rmSync(tempDir, { recursive: true, force: true });
+        if (code === 0) {
+          resolve({ success: true, outputPath: opts.outputPath });
+        } else {
+          resolve({ success: false, error: `dpkg-deb exited with code ${code}` });
+        }
+      });
+      proc.on("error", (err) => {
+        rmSync(tempDir, { recursive: true, force: true });
+        resolve({ success: false, error: err.message });
+      });
+    } catch (error) {
+      resolve({ success: false, error: error.message });
+    }
+  });
+}
+async function createRPM(opts) {
+  return new Promise((resolve) => {
+    try {
+      const buildRoot = join(homedir(), "rpmbuild");
+      const specDir = join(buildRoot, "SPECS");
+      const sourcesDir = join(buildRoot, "SOURCES");
+      const buildDir = join(buildRoot, "BUILD");
+      const rpmsDir = join(buildRoot, "RPMS");
+      mkdirSync(specDir, { recursive: true });
+      mkdirSync(sourcesDir, { recursive: true });
+      mkdirSync(buildDir, { recursive: true });
+      mkdirSync(rpmsDir, { recursive: true });
+      const safePackageName = /^[a-z0-9._+-]+$/i;
+      const safeVersion = /^[A-Za-z0-9._+-]+$/;
+      const sanitizedName = opts.name.toLowerCase();
+      if (!safePackageName.test(sanitizedName)) {
+        return resolve({ success: false, error: `RPM package name must match ${safePackageName} (got: ${sanitizedName})` });
+      }
+      if (!safeVersion.test(opts.version)) {
+        return resolve({ success: false, error: `RPM version must match ${safeVersion} (got: ${opts.version})` });
+      }
+      const cleanLine = (s) => s.replace(/[\r\n]+/g, " ").replace(/%/g, "%%");
+      const summary = cleanLine(opts.description || opts.name);
+      const description = (opts.description || opts.name).split(/\r?\n/).map((line) => line.replace(/%/g, "%%")).join(`
+`);
+      const requires = opts.requires.map((r) => {
+        if (!safePackageName.test(r)) {
+          throw new Error(`RPM Requires entry must match ${safePackageName} (got: ${r})`);
+        }
+        return r;
+      }).join(", ");
+      copyFileSync(opts.binaryPath, join(sourcesDir, sanitizedName));
+      const specContent = `Name: ${sanitizedName}
+Version: ${opts.version}
+Release: 1%{?dist}
+Summary: ${summary}
+License: MIT
+Requires: ${requires}
+
+%description
+${description}
+
+%install
+mkdir -p %{buildroot}/usr/bin
+install -m 755 %{SOURCE0} %{buildroot}/usr/bin/${sanitizedName}
+
+%files
+/usr/bin/${sanitizedName}
+`;
+      const specPath = join(specDir, `${opts.name.toLowerCase()}.spec`);
+      writeFileSync(specPath, specContent);
+      const proc = spawn("rpmbuild", ["-bb", specPath]);
+      proc.on("close", (code) => {
+        if (code === 0) {
+          const rpmName = `${opts.name.toLowerCase()}-${opts.version}-1.x86_64.rpm`;
+          const builtRpmPath = join(rpmsDir, "x86_64", rpmName);
+          try {
+            copyFileSync(builtRpmPath, opts.outputPath);
+            resolve({ success: true, outputPath: opts.outputPath });
+          } catch {
+            resolve({ success: false, error: "Failed to copy built RPM" });
+          }
+        } else {
+          resolve({ success: false, error: `rpmbuild exited with code ${code}` });
+        }
+      });
+      proc.on("error", (err) => {
+        resolve({ success: false, error: err.message });
+      });
+    } catch (error) {
+      resolve({ success: false, error: error.message });
+    }
+  });
+}
+async function createAppImage(opts) {
+  return new Promise((resolve) => {
+    try {
+      const appDir = mkdtempSync(join(tmpdir(), "craft-appimage-"));
+      const appDirPath = join(appDir, `${opts.name}.AppDir`);
+      const binDir = join(appDirPath, "usr", "bin");
+      const shareDir = join(appDirPath, "usr", "share");
+      mkdirSync(binDir, { recursive: true });
+      mkdirSync(shareDir, { recursive: true });
+      const binaryName = opts.name.toLowerCase();
+      copyFileSync(opts.binaryPath, join(binDir, binaryName));
+      chmodSync(join(binDir, binaryName), 493);
+      const appRunContent = `#!/bin/bash
+SELF=$(readlink -f "$0")
+HERE=\${SELF%/*}
+export PATH="\${HERE}/usr/bin/:\${PATH}"
+exec "\${HERE}/usr/bin/${binaryName}" "$@"
+`;
+      writeFileSync(join(appDirPath, "AppRun"), appRunContent);
+      chmodSync(join(appDirPath, "AppRun"), 493);
+      const desktopContent = `[Desktop Entry]
+Type=Application
+Name=${opts.name}
+Exec=${binaryName}
+Terminal=false
+Categories=Utility;
+Icon=${binaryName}
+`;
+      writeFileSync(join(appDirPath, `${binaryName}.desktop`), desktopContent);
+      if (opts.iconPath && existsSync3(opts.iconPath)) {
+        copyFileSync(opts.iconPath, join(appDirPath, `${binaryName}.png`));
+      } else {
+        const placeholderPng = Buffer.from([
+          137,
+          80,
+          78,
+          71,
+          13,
+          10,
+          26,
+          10,
+          0,
+          0,
+          0,
+          13,
+          73,
+          72,
+          68,
+          82,
+          0,
+          0,
+          0,
+          1,
+          0,
+          0,
+          0,
+          1,
+          8,
+          2,
+          0,
+          0,
+          0,
+          144,
+          119,
+          83,
+          222,
+          0,
+          0,
+          0,
+          12,
+          73,
+          68,
+          65,
+          84,
+          8,
+          215,
+          99,
+          248,
+          255,
+          255,
+          63,
+          0,
+          5,
+          254,
+          2,
+          254,
+          220,
+          204,
+          89,
+          231,
+          0,
+          0,
+          0,
+          0,
+          73,
+          69,
+          78,
+          68,
+          174,
+          66,
+          96,
+          130
+        ]);
+        writeFileSync(join(appDirPath, `${binaryName}.png`), placeholderPng);
+      }
+      const proc = spawn("appimagetool", [appDirPath, opts.outputPath], {
+        env: { ...process.env, ARCH: "x86_64" }
+      });
+      proc.on("close", (code) => {
+        rmSync(appDir, { recursive: true, force: true });
+        if (code === 0) {
+          chmodSync(opts.outputPath, 493);
+          resolve({ success: true, outputPath: opts.outputPath });
+        } else {
+          resolve({ success: false, error: `appimagetool exited with code ${code}. Install from https://appimage.github.io/appimagetool/` });
+        }
+      });
+      proc.on("error", (err) => {
+        rmSync(appDir, { recursive: true, force: true });
+        resolve({ success: false, error: `appimagetool not found: ${err.message}` });
+      });
+    } catch (error) {
+      resolve({ success: false, error: error.message });
+    }
+  });
+}
+function detectPlatform() {
+  switch (process.platform) {
+    case "darwin":
+      return "macos";
+    case "win32":
+      return "windows";
+    default:
+      return "linux";
+  }
+}
+async function pack(options) {
+  return packageApp({
+    ...options,
+    platforms: [detectPlatform()]
+  });
+}
+var CRC32_TABLE, MEBIBYTE, HDIUTIL_MAX_ATTEMPTS = 3, runHdiutil = (args) => runTool("hdiutil", args);
+var init_package = __esm(() => {
+  CRC32_TABLE = (() => {
+    const table = new Uint32Array(256);
+    for (let n = 0;n < 256; n++) {
+      let c = n;
+      for (let k = 0;k < 8; k++)
+        c = c & 1 ? 3988292384 ^ c >>> 1 : c >>> 1;
+      table[n] = c >>> 0;
+    }
+    return table;
+  })();
+  MEBIBYTE = 1024 * 1024;
+});
+
+// dist/ios/src/index.js
+var exports_src = {};
+__export(exports_src, {
+  run: () => run,
+  open: () => open,
+  init: () => init,
+  build: () => build
+});
+import { readFileSync as readFileSync2, writeFileSync as writeFileSync2, mkdirSync as mkdirSync2, existsSync as existsSync4, readdirSync as readdirSync2 } from "fs";
+import { join as join2, dirname } from "path";
+async function init(options) {
+  const { name, bundleId, teamId, output } = options;
+  console.log(`
+\u26A1 Initializing Craft iOS project: ${name}`);
+  console.log(`   Output: ${output}
+`);
+  const dirs = [output, join2(output, "Sources"), join2(output, "dist")];
+  for (const dir of dirs) {
+    if (!existsSync4(dir)) {
+      mkdirSync2(dir, { recursive: true });
+    }
+  }
+  const finalBundleId = bundleId || `com.craft.${name.toLowerCase().replace(/[^a-z0-9]/g, "")}`;
+  const bundleIdPrefix = finalBundleId.split(".").slice(0, -1).join(".");
+  const config = {
+    appName: name,
+    bundleId: finalBundleId,
+    version: "1.0.0",
+    buildNumber: "1",
+    darkMode: true,
+    backgroundColor: "#1a1a2e",
+    enableSpeechRecognition: true,
+    enableHaptics: true,
+    enableShare: true,
+    iosVersion: "15.0",
+    teamId: teamId || ""
+  };
+  writeFileSync2(join2(output, "craft.config.json"), JSON.stringify(config, null, 2));
+  const swiftTemplate = readFileSync2(join2(TEMPLATES_DIR, "CraftApp.swift"), "utf-8");
+  writeFileSync2(join2(output, "Sources", `${name}App.swift`), swiftTemplate.replace(/CraftApp/g, `${name}App`));
+  const infoPlistTemplate = readFileSync2(join2(TEMPLATES_DIR, "Info.plist.template"), "utf-8");
+  const infoPlist = infoPlistTemplate.replace(/\{\{APP_NAME\}\}/g, name).replace(/\{\{BUNDLE_ID\}\}/g, finalBundleId).replace(/\{\{VERSION\}\}/g, config.version || "1.0.0").replace(/\{\{BUILD_NUMBER\}\}/g, config.buildNumber || "1").replace(/\{\{UI_STYLE\}\}/g, config.darkMode ? "Dark" : "Light");
+  writeFileSync2(join2(output, "Info.plist"), infoPlist);
+  const projectYmlTemplate = readFileSync2(join2(TEMPLATES_DIR, "project.yml.template"), "utf-8");
+  const projectYml = projectYmlTemplate.replace(/\{\{APP_NAME\}\}/g, name).replace(/\{\{BUNDLE_ID\}\}/g, finalBundleId).replace(/\{\{BUNDLE_ID_PREFIX\}\}/g, bundleIdPrefix).replace(/\{\{VERSION\}\}/g, config.version || "1.0.0").replace(/\{\{BUILD_NUMBER\}\}/g, config.buildNumber || "1").replace(/\{\{IOS_VERSION\}\}/g, config.iosVersion || "15.0").replace(/\{\{TEAM_ID\}\}/g, teamId || "");
+  writeFileSync2(join2(output, "project.yml"), projectYml);
+  const placeholderHtml = `<!DOCTYPE html>
+<html>
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="viewport-fit=cover, width=device-width, initial-scale=1.0, maximum-scale=1.0, user-scalable=no">
+  <title>${name}</title>
+  <style>
+    * { margin: 0; padding: 0; box-sizing: border-box; }
+    body {
+      font-family: -apple-system, system-ui, sans-serif;
+      background: ${config.backgroundColor};
+      color: white;
+      min-height: 100vh;
+      display: flex;
+      justify-content: center;
+      align-items: center;
+      padding: env(safe-area-inset-top) env(safe-area-inset-right) env(safe-area-inset-bottom) env(safe-area-inset-left);
+    }
+    .container { text-align: center; padding: 2rem; }
+    h1 { font-size: 2.5rem; margin-bottom: 1rem; }
+    p { opacity: 0.7; }
+    .ready { color: #4ade80; font-size: 0.9rem; margin-top: 2rem; }
+  </style>
+</head>
+<body>
+  <div class="container">
+    <h1>\u26A1 ${name}</h1>
+    <p>Built with Craft iOS</p>
+    <p class="ready" id="status">Waiting for Craft bridge...</p>
+  </div>
+  <script>
+    window.addEventListener('craftReady', (e) => {
+      document.getElementById('status').textContent = \`\u2713 Craft bridge ready (platform: \${e.detail.platform})\`;
+      console.log('Craft capabilities:', e.detail.capabilities);
+    });
+  </script>
+</body>
+</html>`;
+  writeFileSync2(join2(output, "dist", "index.html"), placeholderHtml);
+  console.log("\u2705 Project initialized");
+  console.log("");
+  console.log("Next steps:");
+  console.log(`  1. cd ${output}`);
+  console.log("  2. Add your web content to dist/index.html");
+  console.log("  3. Run: craft ios build");
+  console.log("  4. Run: craft ios open");
+  console.log("");
+}
+async function build(options) {
+  const { htmlPath, devServer, output } = options;
+  console.log(`
+\uD83D\uDCE6 Building Craft iOS project...`);
+  const configPath = join2(output, "craft.config.json");
+  if (!existsSync4(configPath)) {
+    throw new Error(`No craft.config.json found in ${output}. Run 'craft ios init' first.`);
+  }
+  const config = JSON.parse(readFileSync2(configPath, "utf-8"));
+  if (devServer) {
+    config.devServerURL = devServer;
+    writeFileSync2(configPath, JSON.stringify(config, null, 2));
+    console.log(`   Dev server: ${devServer}`);
+  }
+  if (htmlPath) {
+    const distDir = join2(output, "dist");
+    if (!existsSync4(distDir)) {
+      mkdirSync2(distDir, { recursive: true });
+    }
+    if (existsSync4(htmlPath)) {
+      const stat = await Bun.file(htmlPath).exists();
+      if (stat) {
+        const html = readFileSync2(htmlPath, "utf-8");
+        writeFileSync2(join2(distDir, "index.html"), html);
+        console.log(`   Copied: ${htmlPath} \u2192 dist/index.html`);
+      }
+    } else {
+      throw new Error(`HTML path not found: ${htmlPath}`);
+    }
+  }
+  try {
+    const result = await $`which xcodegen`.quiet();
+    if (result.exitCode === 0) {
+      console.log("   Running xcodegen...");
+      await $`cd ${output} && xcodegen generate`.quiet();
+      console.log(`\u2705 Xcode project created: ${config.appName}.xcodeproj`);
+    } else {
+      throw new Error("xcodegen not found");
+    }
+  } catch {
+    console.log("\u26A0\uFE0F  xcodegen not found. Install with: brew install xcodegen");
+    console.log("   Then run: craft ios build");
+    return;
+  }
+  console.log("");
+}
+async function open(options) {
+  const { output } = options;
+  const files = readdirSync2(output);
+  const xcodeproj = files.find((f) => f.endsWith(".xcodeproj"));
+  if (!xcodeproj) {
+    throw new Error(`No Xcode project found in ${output}. Run 'craft ios build' first.`);
+  }
+  const projectPath = join2(output, xcodeproj);
+  console.log(`\uD83D\uDE80 Opening ${xcodeproj}...`);
+  await $`open ${projectPath}`;
+}
+async function run(options) {
+  const { simulator, output } = options;
+  await build({ output });
+  const files = readdirSync2(output);
+  const xcodeproj = files.find((f) => f.endsWith(".xcodeproj"));
+  if (!xcodeproj) {
+    throw new Error(`No Xcode project found in ${output}`);
+  }
+  const projectPath = join2(output, xcodeproj);
+  const appName = xcodeproj.replace(".xcodeproj", "");
+  if (simulator) {
+    console.log("\uD83D\uDCF1 Building and running on simulator...");
+    try {
+      await $`xcodebuild -project ${projectPath} -scheme ${appName} -destination 'platform=iOS Simulator,name=iPhone 15' build`;
+      await $`xcrun simctl boot "iPhone 15"`.quiet().nothrow();
+      await $`open -a Simulator`;
+      console.log("\u2705 App deployed to simulator");
+    } catch (error) {
+      console.error("Build failed. Open in Xcode for details:", projectPath);
+    }
+  } else {
+    console.log("\uD83D\uDCF1 Opening Xcode for device deployment...");
+    await $`open ${projectPath}`;
+    console.log("");
+    console.log("In Xcode:");
+    console.log("  1. Select your Team in Signing & Capabilities");
+    console.log("  2. Connect your iPhone");
+    console.log("  3. Select your device");
+    console.log("  4. Click Run (\u25B6\uFE0F)");
+  }
+}
+var $, TEMPLATES_DIR;
+var init_src = __esm(() => {
+  ({ $ } = globalThis.Bun);
+  TEMPLATES_DIR = join2(dirname(import.meta.dir), "templates");
+});
+
+// dist/android/src/index.js
+var exports_src2 = {};
+__export(exports_src2, {
+  run: () => run2,
+  open: () => open2,
+  init: () => init2,
+  build: () => build2
+});
+import { readFileSync as readFileSync3, writeFileSync as writeFileSync3, mkdirSync as mkdirSync3, existsSync as existsSync5, statSync } from "fs";
+import { join as join3, dirname as dirname2 } from "path";
+async function init2(options) {
+  const { name, packageName, output } = options;
+  console.log(`
+\u26A1 Initializing Craft Android project: ${name}`);
+  console.log(`   Output: ${output}
+`);
+  const finalPackageName = packageName || `com.craft.${name.toLowerCase().replace(/[^a-z0-9]/g, "")}`;
+  const packagePath = finalPackageName.replace(/\./g, "/");
+  const dirs = [
+    output,
+    join3(output, "app/src/main/java", packagePath),
+    join3(output, "app/src/main/res/layout"),
+    join3(output, "app/src/main/res/values"),
+    join3(output, "app/src/main/res/drawable"),
+    join3(output, "app/src/main/assets"),
+    join3(output, "gradle/wrapper")
+  ];
+  for (const dir of dirs) {
+    if (!existsSync5(dir)) {
+      mkdirSync3(dir, { recursive: true });
+    }
+  }
+  const config = {
+    appName: name,
+    packageName: finalPackageName,
+    version: "1.0.0",
+    versionCode: 1,
+    darkMode: true,
+    backgroundColor: "#1a1a2e",
+    enableSpeechRecognition: true,
+    enableHaptics: true,
+    enableShare: true,
+    enableCamera: true,
+    enableBiometric: true,
+    enablePushNotifications: false,
+    minSdk: 24,
+    targetSdk: 34
+  };
+  writeFileSync3(join3(output, "craft.config.json"), JSON.stringify(config, null, 2));
+  const mainActivityTemplate = readFileSync3(join3(TEMPLATES_DIR2, "MainActivity.kt.template"), "utf-8");
+  const mainActivity = mainActivityTemplate.replace(/\{\{PACKAGE_NAME\}\}/g, finalPackageName).replace(/\{\{APP_NAME\}\}/g, name);
+  writeFileSync3(join3(output, "app/src/main/java", packagePath, "MainActivity.kt"), mainActivity);
+  const craftBridgeTemplate = readFileSync3(join3(TEMPLATES_DIR2, "CraftBridge.kt.template"), "utf-8");
+  const craftBridge = craftBridgeTemplate.replace(/\{\{PACKAGE_NAME\}\}/g, finalPackageName);
+  writeFileSync3(join3(output, "app/src/main/java", packagePath, "CraftBridge.kt"), craftBridge);
+  const manifestTemplate = readFileSync3(join3(TEMPLATES_DIR2, "AndroidManifest.xml.template"), "utf-8");
+  const manifest = manifestTemplate.replace(/\{\{PACKAGE_NAME\}\}/g, finalPackageName).replace(/\{\{APP_NAME\}\}/g, name);
+  writeFileSync3(join3(output, "app/src/main/AndroidManifest.xml"), manifest);
+  const projectGradleTemplate = readFileSync3(join3(TEMPLATES_DIR2, "build.gradle.kts.project.template"), "utf-8");
+  writeFileSync3(join3(output, "build.gradle.kts"), projectGradleTemplate);
+  const appGradleTemplate = readFileSync3(join3(TEMPLATES_DIR2, "build.gradle.kts.app.template"), "utf-8");
+  const appGradle = appGradleTemplate.replace(/\{\{PACKAGE_NAME\}\}/g, finalPackageName).replace(/\{\{VERSION_NAME\}\}/g, config.version || "1.0.0").replace(/\{\{VERSION_CODE\}\}/g, String(config.versionCode || 1)).replace(/\{\{MIN_SDK\}\}/g, String(config.minSdk || 24)).replace(/\{\{TARGET_SDK\}\}/g, String(config.targetSdk || 34));
+  writeFileSync3(join3(output, "app/build.gradle.kts"), appGradle);
+  const settingsTemplate = readFileSync3(join3(TEMPLATES_DIR2, "settings.gradle.kts.template"), "utf-8");
+  const settings2 = settingsTemplate.replace(/\{\{APP_NAME\}\}/g, name);
+  writeFileSync3(join3(output, "settings.gradle.kts"), settings2);
+  const gradleProperties = `org.gradle.jvmargs=-Xmx2048m -Dfile.encoding=UTF-8
+android.useAndroidX=true
+kotlin.code.style=official
+android.nonTransitiveRClass=true
+`;
+  writeFileSync3(join3(output, "gradle.properties"), gradleProperties);
+  writeFileSync3(join3(output, "local.properties"), `# SDK location will be set by Android Studio
+`);
+  const gradleWrapperProps = `distributionBase=GRADLE_USER_HOME
+distributionPath=wrapper/dists
+distributionUrl=https\\://services.gradle.org/distributions/gradle-8.4-bin.zip
+networkTimeout=10000
+validateDistributionUrl=true
+zipStoreBase=GRADLE_USER_HOME
+zipStorePath=wrapper/dists
+`;
+  writeFileSync3(join3(output, "gradle/wrapper/gradle-wrapper.properties"), gradleWrapperProps);
+  const stringsXml = `<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <string name="app_name">${name}</string>
+</resources>
+`;
+  writeFileSync3(join3(output, "app/src/main/res/values/strings.xml"), stringsXml);
+  const colorsXml = `<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <color name="primary">#1a1a2e</color>
+    <color name="primary_dark">#16162b</color>
+    <color name="accent">#4ade80</color>
+    <color name="background">${config.backgroundColor}</color>
+</resources>
+`;
+  writeFileSync3(join3(output, "app/src/main/res/values/colors.xml"), colorsXml);
+  const themesXml = `<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <style name="Theme.CraftApp" parent="Theme.Material3.DayNight.NoActionBar">
+        <item name="android:statusBarColor">@color/primary_dark</item>
+        <item name="android:navigationBarColor">@color/primary</item>
+        <item name="android:windowBackground">@color/background</item>
+    </style>
+</resources>
+`;
+  writeFileSync3(join3(output, "app/src/main/res/values/themes.xml"), themesXml);
+  const activityMainXml = `<?xml version="1.0" encoding="utf-8"?>
+<androidx.coordinatorlayout.widget.CoordinatorLayout
+    xmlns:android="http://schemas.android.com/apk/res/android"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent"
+    android:fitsSystemWindows="true">
+
+    <WebView
+        android:id="@+id/webview"
+        android:layout_width="match_parent"
+        android:layout_height="match_parent" />
+
+</androidx.coordinatorlayout.widget.CoordinatorLayout>
+`;
+  writeFileSync3(join3(output, "app/src/main/res/layout/activity_main.xml"), activityMainXml);
+  const placeholderHtml = `<!DOCTYPE html>
+<html>
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="viewport-fit=cover, width=device-width, initial-scale=1.0, maximum-scale=1.0, user-scalable=no">
+  <title>${name}</title>
+  <style>
+    * { margin: 0; padding: 0; box-sizing: border-box; }
+    body {
+      font-family: 'Roboto', sans-serif;
+      background: ${config.backgroundColor};
+      color: white;
+      min-height: 100vh;
+      display: flex;
+      justify-content: center;
+      align-items: center;
+    }
+    .container { text-align: center; padding: 2rem; }
+    h1 { font-size: 2.5rem; margin-bottom: 1rem; }
+    p { opacity: 0.7; }
+    .ready { color: #4ade80; font-size: 0.9rem; margin-top: 2rem; }
+  </style>
+</head>
+<body>
+  <div class="container">
+    <h1>\u26A1 ${name}</h1>
+    <p>Built with Craft Android</p>
+    <p class="ready" id="status">Waiting for Craft bridge...</p>
+  </div>
+  <script>
+    window.addEventListener('craftReady', (e) => {
+      document.getElementById('status').textContent = \`\u2713 Craft bridge ready (platform: \${e.detail.platform})\`;
+      console.log('Craft capabilities:', e.detail.capabilities);
+    });
+  </script>
+</body>
+</html>`;
+  writeFileSync3(join3(output, "app/src/main/assets/index.html"), placeholderHtml);
+  console.log("\u2705 Project initialized");
+  console.log("");
+  console.log("Next steps:");
+  console.log(`  1. cd ${output}`);
+  console.log("  2. Add your web content to app/src/main/assets/index.html");
+  console.log("  3. Run: craft android build");
+  console.log("  4. Run: craft android open");
+  console.log("");
+}
+async function build2(options) {
+  const { htmlPath, devServer, output, release } = options;
+  console.log(`
+\uD83D\uDCE6 Building Craft Android project...`);
+  const configPath = join3(output, "craft.config.json");
+  if (!existsSync5(configPath)) {
+    throw new Error(`No craft.config.json found in ${output}. Run 'craft android init' first.`);
+  }
+  const config = JSON.parse(readFileSync3(configPath, "utf-8"));
+  if (devServer) {
+    config.devServerURL = devServer;
+    writeFileSync3(configPath, JSON.stringify(config, null, 2));
+    console.log(`   Dev server: ${devServer}`);
+  }
+  if (htmlPath) {
+    const assetsDir = join3(output, "app/src/main/assets");
+    if (!existsSync5(assetsDir)) {
+      mkdirSync3(assetsDir, { recursive: true });
+    }
+    if (existsSync5(htmlPath) && statSync(htmlPath).isFile()) {
+      const html = readFileSync3(htmlPath, "utf-8");
+      writeFileSync3(join3(assetsDir, "index.html"), html);
+      console.log(`   Copied: ${htmlPath} \u2192 assets/index.html`);
+    } else {
+      throw new Error(`HTML file not found or is a directory: ${htmlPath}`);
+    }
+  }
+  const gradlewPath = join3(output, "gradlew");
+  if (!existsSync5(gradlewPath)) {
+    console.log("   Generating Gradle wrapper...");
+    try {
+      await $2`cd ${output} && gradle wrapper`.quiet();
+    } catch {
+      console.log("\u26A0\uFE0F  Gradle not found. Please install Android Studio or Gradle.");
+      console.log("   Download: https://developer.android.com/studio");
+      return;
+    }
+  }
+  const buildType = release ? "assembleRelease" : "assembleDebug";
+  console.log(`   Building ${release ? "release" : "debug"} APK...`);
+  try {
+    await $2`cd ${output} && ./gradlew ${buildType}`;
+    const apkPath = release ? "app/build/outputs/apk/release/app-release.apk" : "app/build/outputs/apk/debug/app-debug.apk";
+    console.log(`\u2705 APK built: ${apkPath}`);
+  } catch (error) {
+    console.error("Build failed. Open in Android Studio for details.");
+    throw error;
+  }
+  console.log("");
+}
+async function open2(options) {
+  const { output } = options;
+  if (!existsSync5(output)) {
+    throw new Error(`No Android project found in ${output}. Run 'craft android init' first.`);
+  }
+  console.log(`\uD83D\uDE80 Opening Android project in Android Studio...`);
+  try {
+    await $2`open -a "Android Studio" ${output}`.quiet();
+  } catch {
+    try {
+      await $2`studio ${output}`.quiet();
+    } catch {
+      console.log("\u26A0\uFE0F  Android Studio not found.");
+      console.log("   Please open the project manually in Android Studio:");
+      console.log(`   ${output}`);
+    }
+  }
+}
+async function run2(options) {
+  const { device, output } = options;
+  await build2({ output });
+  console.log("\uD83D\uDCF1 Installing and running on device...");
+  try {
+    const apkPath = join3(output, "app/build/outputs/apk/debug/app-debug.apk");
+    if (device) {
+      await $2`adb -s ${device} install -r ${apkPath}`;
+    } else {
+      await $2`adb install -r ${apkPath}`;
+    }
+    const config = JSON.parse(readFileSync3(join3(output, "craft.config.json"), "utf-8"));
+    const launchCmd = `${config.packageName}/.MainActivity`;
+    if (device) {
+      await $2`adb -s ${device} shell am start -n ${launchCmd}`;
+    } else {
+      await $2`adb shell am start -n ${launchCmd}`;
+    }
+    console.log("\u2705 App launched");
+  } catch (error) {
+    console.error("Failed to install/run. Make sure:");
+    console.error("  1. ADB is installed and in PATH");
+    console.error("  2. A device/emulator is connected (run: adb devices)");
+    throw error;
+  }
+}
+var $2, TEMPLATES_DIR2;
+var init_src2 = __esm(() => {
+  ({ $: $2 } = globalThis.Bun);
+  TEMPLATES_DIR2 = join3(dirname2(import.meta.dir), "templates");
+});
+
+// ../../node_modules/@stacksjs/clapp/dist/index.js
+import { existsSync } from "fs";
+import fs from "fs/promises";
+import os from "os";
+import path from "path";
+import process2 from "process";
+import { EventEmitter } from "events";
+import process5 from "process";
+import process22 from "process";
+import process3 from "process";
+import process4 from "process";
+import process7 from "process";
+import tty from "tty";
+import process8, { stdin, stdout } from "process";
+import process9, { stdin as stdin2, stdout as stdout2 } from "process";
+import readline2 from "readline";
+class Telemetry {
+  configPath;
+  config = null;
+  events = [];
+  retryCount = 0;
+  maxRetries = 3;
+  retryDelayMs = 1000;
+  constructor() {
+    const homeDir = os.homedir();
+    const configDir = path.join(homeDir, ".config", "clapp");
+    this.configPath = path.join(configDir, "telemetry.json");
+  }
+  async isEnabled() {
+    if (process2.env.DO_NOT_TRACK === "1" || process2.env.DO_NOT_TRACK === "true") {
+      return false;
+    }
+    if (process2.env.NO_TELEMETRY === "1" || process2.env.NO_TELEMETRY === "true") {
+      return false;
+    }
+    const config = await this.loadConfig();
+    return config.enabled;
+  }
+  async enable() {
+    const config = await this.loadConfig();
+    config.enabled = true;
+    if (!config.userId) {
+      config.userId = this.generateUserId();
+    }
+    await this.saveConfig(config);
+  }
+  async disable() {
+    const config = await this.loadConfig();
+    config.enabled = false;
+    await this.saveConfig(config);
+  }
+  async track(event, data) {
+    const enabled = await this.isEnabled();
+    if (!enabled) {
+      return;
+    }
+    const telemetryEvent = {
+      event,
+      ...data,
+      timestamp: Date.now(),
+      platform: os.platform(),
+      nodeVersion: process2.version
+    };
+    this.events.push(telemetryEvent);
+    if (this.events.length >= 10) {
+      await this.send();
+    }
+  }
+  async trackCommand(command, duration) {
+    await this.track("command", {
+      command,
+      duration
+    });
+  }
+  async trackError(error, command) {
+    await this.track("error", {
+      error,
+      command
+    });
+  }
+  async send() {
+    const enabled = await this.isEnabled();
+    if (!enabled || this.events.length === 0) {
+      return true;
+    }
+    try {
+      this.events = [];
+      this.retryCount = 0;
+      const config = await this.loadConfig();
+      config.lastSent = Date.now();
+      await this.saveConfig(config);
+      return true;
+    } catch {
+      if (this.retryCount < this.maxRetries) {
+        this.retryCount++;
+        const delay = this.retryDelayMs * 2 ** (this.retryCount - 1);
+        await this.sleep(delay);
+        return this.send();
+      }
+      this.events = [];
+      this.retryCount = 0;
+      return false;
+    }
+  }
+  async flush() {
+    if (this.events.length === 0) {
+      return true;
+    }
+    return this.send();
+  }
+  sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+  async status() {
+    const config = await this.loadConfig();
+    return {
+      enabled: config.enabled,
+      doNotTrack: process2.env.DO_NOT_TRACK === "1" || process2.env.DO_NOT_TRACK === "true",
+      eventsQueued: this.events.length,
+      lastSent: config.lastSent
+    };
+  }
+  async loadConfig() {
+    if (this.config) {
+      return this.config;
+    }
+    try {
+      if (existsSync(this.configPath)) {
+        const data = await fs.readFile(this.configPath, "utf-8");
+        this.config = JSON.parse(data);
+        return this.config;
+      }
+    } catch {}
+    this.config = {
+      enabled: false
+    };
+    return this.config;
+  }
+  async saveConfig(config) {
+    this.config = config;
+    try {
+      const configDir = path.dirname(this.configPath);
+      await fs.mkdir(configDir, { recursive: true });
+      await fs.writeFile(this.configPath, JSON.stringify(config, null, 2), "utf-8");
+    } catch {}
+  }
+  generateUserId() {
+    const random = Math.random().toString(36).substring(2, 15);
+    const timestamp = Date.now().toString(36);
+    return `${random}-${timestamp}`;
+  }
+}
+var telemetry = new Telemetry;
+function parseArgv(argv, opts = {}) {
+  const result = { _: [] };
+  const alias = opts.alias || {};
+  const booleans = new Set(opts.boolean || []);
+  const aliasOf = {};
+  for (const key of Object.keys(alias)) {
+    for (const a of alias[key]) {
+      aliasOf[a] = key;
+    }
+  }
+  for (const b of booleans) {
+    if (alias[b]) {
+      for (const a of alias[b])
+        booleans.add(a);
+    }
+  }
+  function setKey(key, value) {
+    const canonical = aliasOf[key] || key;
+    result[canonical] = value;
+    if (alias[canonical]) {
+      for (const a of alias[canonical])
+        result[a] = value;
+    }
+    if (aliasOf[key] && alias[aliasOf[key]]) {
+      for (const a of alias[aliasOf[key]])
+        result[a] = value;
+    }
+    result[key] = value;
+  }
+  for (let i = 0;i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg === "--") {
+      result._.push(...argv.slice(i + 1));
+      break;
+    }
+    if (arg.startsWith("--")) {
+      const eqIdx = arg.indexOf("=");
+      if (eqIdx !== -1) {
+        const key = arg.slice(2, eqIdx);
+        const value = arg.slice(eqIdx + 1);
+        setKey(key, value);
+      } else {
+        const key = arg.slice(2);
+        if (key.startsWith("no-")) {
+          const actualKey = key.slice(3);
+          setKey(actualKey, false);
+          continue;
+        }
+        const canonical = aliasOf[key] || key;
+        if (booleans.has(canonical) || booleans.has(key)) {
+          setKey(key, true);
+        } else {
+          const next = argv[i + 1];
+          if (next !== undefined && !next.startsWith("-")) {
+            setKey(key, next);
+            i++;
+          } else {
+            setKey(key, true);
+          }
+        }
+      }
+    } else if (arg.startsWith("-") && arg.length > 1) {
+      const chars = arg.slice(1);
+      for (let j = 0;j < chars.length; j++) {
+        const ch = chars[j];
+        const canonical = aliasOf[ch] || ch;
+        if (j === chars.length - 1 && !booleans.has(canonical) && !booleans.has(ch)) {
+          const next = argv[i + 1];
+          if (next !== undefined && !next.startsWith("-")) {
+            setKey(ch, next);
+            i++;
+          } else {
+            setKey(ch, true);
+          }
+        } else {
+          setKey(ch, true);
+        }
+      }
+    } else {
+      result._.push(arg);
+    }
+  }
+  return result;
+}
+function removeBrackets(v) {
+  return v.replace(/[<[].+/, "").trim();
+}
+function findAllBrackets(v) {
+  const ANGLED_BRACKET_RE_GLOBAL = /<([^>]+)>/g;
+  const SQUARE_BRACKET_RE_GLOBAL = /\[([^\]]+)\]/g;
+  const res = [];
+  const parse = (match) => {
+    let variadic = false;
+    let value = match[1];
+    if (value.startsWith("...")) {
+      value = value.slice(3);
+      variadic = true;
+    }
+    return {
+      required: match[0].startsWith("<"),
+      value,
+      variadic
+    };
+  };
+  let angledMatch;
+  while (angledMatch = ANGLED_BRACKET_RE_GLOBAL.exec(v)) {
+    res.push(parse(angledMatch));
+  }
+  let squareMatch;
+  while (squareMatch = SQUARE_BRACKET_RE_GLOBAL.exec(v)) {
+    res.push(parse(squareMatch));
+  }
+  return res;
+}
+function getMriOptions(options) {
+  const result = { alias: {}, boolean: [] };
+  for (const [index, option] of options.entries()) {
+    if (option.names.length > 1) {
+      result.alias[option.names[0]] = option.names.slice(1);
+    }
+    if (option.isBoolean) {
+      if (option.negated) {
+        const hasStringTypeOption = options.some((o, i) => {
+          return i !== index && o.names.some((name) => option.names.includes(name)) && typeof o.required === "boolean";
+        });
+        if (!hasStringTypeOption) {
+          result.boolean.push(option.names[0]);
+        }
+      } else {
+        result.boolean.push(option.names[0]);
+      }
+    }
+  }
+  return result;
+}
+function findLongest(arr) {
+  return arr.reduce((a, b) => a.length >= b.length ? a : b, "");
+}
+function padRight(str, length) {
+  return str.length >= length ? str : `${str}${" ".repeat(length - str.length)}`;
+}
+function camelcase(input) {
+  return input.replace(/([a-z])-([a-z])/g, (_, p1, p2) => {
+    return p1 + p2.toUpperCase();
+  });
+}
+function setDotProp(obj, keys, val) {
+  let i = 0;
+  const length = keys.length;
+  let t = obj;
+  let x;
+  for (;i < length; ++i) {
+    x = t[keys[i]];
+    t = t[keys[i]] = i === length - 1 ? val : x != null ? x : !!~keys[i + 1].indexOf(".") || !(+keys[i + 1] > -1) ? {} : [];
+  }
+}
+function setByType(obj, transforms) {
+  for (const key of Object.keys(transforms)) {
+    const transform = transforms[key];
+    if (transform.shouldTransform) {
+      obj[key] = Array.prototype.concat.call([], obj[key]);
+      if (typeof transform.transformFunction === "function") {
+        obj[key] = obj[key].map(transform.transformFunction);
+      }
+    }
+  }
+}
+function getFileName(input) {
+  const m = /([^\\/]+)$/.exec(input);
+  return m ? m[1] : "";
+}
+function camelcaseOptionName(name) {
+  return name.split(".").map((v, i) => {
+    return i === 0 ? camelcase(v) : v;
+  }).join(".");
+}
+
+class ClappError extends Error {
+  exitCode = 2;
+  isUsageError = true;
+  constructor(message) {
+    super(message);
+    this.name = this.constructor.name;
+    if (typeof Error.captureStackTrace === "function") {
+      Error.captureStackTrace(this, this.constructor);
+    } else {
+      this.stack = new Error(message).stack;
+    }
+  }
+  format(showStack = false) {
+    if (showStack && this.stack) {
+      return `${this.message}
+
+Stack trace:
+${this.stack}`;
+    }
+    return this.message;
+  }
+}
+function isUnicodeSupported() {
+  const { env } = process22;
+  const { TERM, TERM_PROGRAM } = env;
+  if (process22.platform !== "win32") {
+    return TERM !== "linux";
+  }
+  return Boolean(env.WT_SESSION) || Boolean(env.TERMINUS_SUBLIME) || env.ConEmuTask === "{cmd::Cmder}" || TERM_PROGRAM === "Terminus-Sublime" || TERM_PROGRAM === "vscode" || TERM === "xterm-256color" || TERM === "alacritty" || TERM === "rxvt-unicode" || TERM === "rxvt-unicode-256color" || env.TERMINAL_EMULATOR === "JetBrains-JediTerm";
+}
+var ESC = "\x1B";
+var CSI = `${ESC}[`;
+var cursor = {
+  to(x, y) {
+    if (!y)
+      return `${CSI}${x + 1}G`;
+    return `${CSI}${y + 1};${x + 1}H`;
+  },
+  move(x, y) {
+    let ret = "";
+    if (x < 0)
+      ret += `${CSI}${-x}D`;
+    else if (x > 0)
+      ret += `${CSI}${x}C`;
+    if (y < 0)
+      ret += `${CSI}${-y}A`;
+    else if (y > 0)
+      ret += `${CSI}${y}B`;
+    return ret;
+  },
+  up: (count = 1) => `${CSI}${count}A`,
+  down: (count = 1) => `${CSI}${count}B`,
+  forward: (count = 1) => `${CSI}${count}C`,
+  backward: (count = 1) => `${CSI}${count}D`,
+  nextLine: (count = 1) => `${CSI}E`.repeat(count),
+  prevLine: (count = 1) => `${CSI}F`.repeat(count),
+  left: `${CSI}G`,
+  hide: `${CSI}?25l`,
+  show: `${CSI}?25h`,
+  save: `${ESC}7`,
+  restore: `${ESC}8`
+};
+var erase = {
+  screen: `${CSI}2J`,
+  up: (count = 1) => `${CSI}1J`.repeat(count),
+  down: (count = 1) => `${CSI}J`.repeat(count),
+  line: `${CSI}2K`,
+  lineEnd: `${CSI}K`,
+  lineStart: `${CSI}1K`,
+  lines(count) {
+    let clear = "";
+    for (let i = 0;i < count; i++)
+      clear += this.line + (i < count - 1 ? cursor.up() : "");
+    if (count)
+      clear += cursor.left;
+    return clear;
+  }
+};
+var clear = {
+  screen: `${ESC}c`
+};
+function levenshteinDistance(a, b) {
+  const matrix = [];
+  for (let i = 0;i <= b.length; i++) {
+    matrix[i] = [i];
+  }
+  for (let j = 0;j <= a.length; j++) {
+    matrix[0][j] = j;
+  }
+  for (let i = 1;i <= b.length; i++) {
+    for (let j = 1;j <= a.length; j++) {
+      if (b.charAt(i - 1) === a.charAt(j - 1)) {
+        matrix[i][j] = matrix[i - 1][j - 1];
+      } else {
+        matrix[i][j] = Math.min(matrix[i - 1][j - 1] + 1, matrix[i][j - 1] + 1, matrix[i - 1][j] + 1);
+      }
+    }
+  }
+  return matrix[b.length][a.length];
+}
+function findSimilarCommands(input, commands, maxDistance = 2, maxSuggestions = 3) {
+  return commands.map((cmd) => ({ cmd, distance: levenshteinDistance(input, cmd) })).filter(({ distance }) => distance <= maxDistance).sort((a, b) => a.distance - b.distance).slice(0, maxSuggestions).map(({ cmd }) => cmd);
+}
+
+class Option {
+  rawName;
+  description;
+  name;
+  names;
+  isBoolean;
+  required;
+  config;
+  negated;
+  constructor(rawName, description, config) {
+    this.rawName = rawName;
+    this.description = description;
+    this.config = Object.assign({}, config);
+    rawName = rawName.replace(/\.\*/g, "");
+    this.negated = false;
+    this.names = removeBrackets(rawName).split(",").map((v) => {
+      let name = v.trim().replace(/^-{1,2}/, "");
+      if (name.startsWith("no-")) {
+        this.negated = true;
+        name = name.replace(/^no-/, "");
+      }
+      return camelcaseOptionName(name);
+    }).sort((a, b) => a.length > b.length ? 1 : -1);
+    this.name = this.names[this.names.length - 1];
+    if (this.negated && this.config.default == null) {
+      this.config.default = true;
+    }
+    if (rawName.includes("<")) {
+      this.required = true;
+    } else if (rawName.includes("[")) {
+      this.required = false;
+    } else {
+      this.isBoolean = true;
+    }
+  }
+}
+var processArgs = process3.argv;
+var platformInfo = `${process3.platform}-${process3.arch} bun-v${typeof Bun !== "undefined" ? Bun.version : "unknown"}`;
+var processArgs2 = process4.argv;
+var platformInfo2 = `${process4.platform}-${process4.arch} node-${process4.version}`;
+
+class Command {
+  rawName;
+  description;
+  config;
+  cli;
+  options;
+  aliasNames;
+  name;
+  namespace;
+  args;
+  commandAction;
+  usageText;
+  versionNumber;
+  examples;
+  helpCallback;
+  globalCommand;
+  beforeHooks;
+  afterHooks;
+  middleware;
+  constructor(rawName, description, config, cli) {
+    this.rawName = rawName;
+    this.description = description;
+    this.config = config;
+    this.cli = cli;
+    this.options = [];
+    this.aliasNames = [];
+    this.name = removeBrackets(rawName);
+    const nameWithoutBrackets = removeBrackets(rawName);
+    const colonIndex = nameWithoutBrackets.indexOf(":");
+    if (colonIndex > 0) {
+      this.namespace = nameWithoutBrackets.substring(0, colonIndex);
+      this.name = nameWithoutBrackets.substring(colonIndex + 1);
+    }
+    this.args = findAllBrackets(rawName);
+    this.examples = [];
+    this.beforeHooks = [];
+    this.afterHooks = [];
+    this.middleware = [];
+    if (!config) {
+      this.config = {};
+    }
+  }
+  usage(text) {
+    this.usageText = text;
+    return this;
+  }
+  allowUnknownOptions() {
+    this.config.allowUnknownOptions = true;
+    return this;
+  }
+  ignoreOptionDefaultValue() {
+    this.config.ignoreOptionDefaultValue = true;
+    return this;
+  }
+  version(version, customFlags = "-v, --version") {
+    this.versionNumber = version;
+    this.option(customFlags, "Display version number");
+    return this;
+  }
+  example(example) {
+    this.examples.push(example);
+    return this;
+  }
+  option(rawName, description, config) {
+    const option = new Option(rawName, description, config);
+    this.options.push(option);
+    return this;
+  }
+  alias(name) {
+    this.aliasNames.push(name);
+    return this;
+  }
+  action(callback) {
+    this.commandAction = callback;
+    return this;
+  }
+  before(handler) {
+    this.beforeHooks.push(handler);
+    return this;
+  }
+  after(handler) {
+    this.afterHooks.push(handler);
+    return this;
+  }
+  use(handler) {
+    this.middleware.push(handler);
+    return this;
+  }
+  isMatched(name) {
+    if (this.aliasNames.includes(name))
+      return true;
+    if (this.namespace)
+      return `${this.namespace}:${this.name}` === name;
+    return this.name === name;
+  }
+  get isDefaultCommand() {
+    return this.name === "" || this.aliasNames.includes("!");
+  }
+  get isGlobalCommand() {
+    return this instanceof GlobalCommand;
+  }
+  get displayName() {
+    return this.namespace ? `${this.namespace}:${this.name}` : this.name;
+  }
+  hasOption(name) {
+    name = name.split(".")[0];
+    return !!this.options.find((option) => {
+      return option.names.includes(name);
+    });
+  }
+  outputHelp() {
+    const { name, commands } = this.cli;
+    const {
+      versionNumber,
+      options: globalOptions,
+      helpCallback
+    } = this.cli.globalCommand;
+    let sections = [
+      {
+        body: `${name}${versionNumber ? `/${versionNumber}` : ""}`
+      }
+    ];
+    sections.push({
+      title: "Usage",
+      body: `  $ ${name} ${this.usageText || this.rawName}`
+    });
+    const showCommands = (this.isGlobalCommand || this.isDefaultCommand) && commands.length > 0;
+    if (showCommands) {
+      const longestCommandName = findLongest(commands.map((command) => command.rawName));
+      const namespaceGroups = new Map;
+      const noNamespaceCommands = [];
+      for (const command of commands) {
+        if (command.namespace) {
+          if (!namespaceGroups.has(command.namespace)) {
+            namespaceGroups.set(command.namespace, []);
+          }
+          namespaceGroups.get(command.namespace).push(command);
+        } else {
+          noNamespaceCommands.push(command);
+        }
+      }
+      let commandBody = "";
+      if (noNamespaceCommands.length > 0) {
+        commandBody += noNamespaceCommands.map((command) => {
+          return `  ${padRight(command.rawName, longestCommandName.length)}  ${command.description}`;
+        }).join(`
+`);
+      }
+      const sortedNamespaces = Array.from(namespaceGroups.keys()).sort();
+      for (const namespace of sortedNamespaces) {
+        const namespaceCommands = namespaceGroups.get(namespace);
+        if (commandBody.length > 0) {
+          commandBody += `
+
+`;
+        }
+        commandBody += `  ${namespace}:
+`;
+        commandBody += namespaceCommands.map((command) => {
+          return `    ${padRight(command.rawName, longestCommandName.length - 2)}  ${command.description}`;
+        }).join(`
+`);
+      }
+      sections.push({
+        title: "Commands",
+        body: commandBody
+      });
+      sections.push({
+        title: `For more info, run any command with the \`--help\` flag`,
+        body: commands.map((command) => `  $ ${name}${command.displayName === "" ? "" : ` ${command.displayName}`} --help`).join(`
+`)
+      });
+    }
+    let options = this.isGlobalCommand ? globalOptions : [...this.options, ...globalOptions || []];
+    if (!this.isGlobalCommand && !this.isDefaultCommand) {
+      options = options.filter((option) => option.name !== "version");
+    }
+    if (options.length > 0) {
+      const longestOptionName = findLongest(options.map((option) => option.rawName));
+      sections.push({
+        title: "Options",
+        body: options.map((option) => {
+          return `  ${padRight(option.rawName, longestOptionName.length)}  ${option.description} ${option.config.default === undefined ? "" : `(default: ${option.config.default})`}`;
+        }).join(`
+`)
+      });
+    }
+    if (this.examples.length > 0) {
+      sections.push({
+        title: "Examples",
+        body: this.examples.map((example) => {
+          if (typeof example === "function") {
+            return example(name);
+          }
+          return example;
+        }).join(`
+`)
+      });
+    }
+    if (helpCallback) {
+      sections = helpCallback(sections) || sections;
+    }
+    console.log(sections.map((section) => {
+      return section.title ? `${section.title}:
+${section.body}` : section.body;
+    }).join(`
+
+`));
+  }
+  outputVersion() {
+    const { name } = this.cli;
+    const { versionNumber } = this.cli.globalCommand;
+    if (versionNumber) {
+      const platformInfo3 = typeof Bun !== "undefined" ? platformInfo : platformInfo2;
+      console.log(`${name}/${versionNumber} ${platformInfo3}`);
+    }
+  }
+  checkRequiredArgs() {
+    const minimalArgsCount = this.args.filter((arg) => arg.required).length;
+    if (this.cli.args.length < minimalArgsCount) {
+      const requiredArgs = this.args.filter((arg) => arg.required);
+      const missingArgs = requiredArgs.slice(this.cli.args.length);
+      const argNames = missingArgs.map((arg) => `<${arg.value}>`).join(" ");
+      throw new ClappError(`Missing required argument${missingArgs.length > 1 ? "s" : ""}: ${argNames}
+
+` + `Run \`${this.cli.name} ${this.rawName} --help\` for usage information.`);
+    }
+  }
+  checkUnknownOptions() {
+    const { options, globalCommand } = this.cli;
+    if (!this.config.allowUnknownOptions) {
+      for (const name of Object.keys(options)) {
+        if (name !== "--" && !this.hasOption(name) && !globalCommand.hasOption(name)) {
+          const allOptions = [...globalCommand.options, ...this.options];
+          const allOptionNames = allOptions.flatMap((opt) => opt.names);
+          const optionFlag = name.length > 1 ? `--${name}` : `-${name}`;
+          const suggestions = findSimilarCommands(name, allOptionNames);
+          let errorMsg = `Unknown option \`${optionFlag}\``;
+          if (suggestions.length > 0) {
+            errorMsg += `
+
+Did you mean one of these?`;
+            suggestions.forEach((suggestion) => {
+              const suggestedFlag = suggestion.length > 1 ? `--${suggestion}` : `-${suggestion}`;
+              errorMsg += `
+  \u2022 ${suggestedFlag}`;
+            });
+          }
+          errorMsg += `
+
+Run \`${this.cli.name} ${this.rawName} --help\` to see available options.`;
+          throw new ClappError(errorMsg);
+        }
+      }
+    }
+  }
+  checkOptionValue() {
+    const { options: parsedOptions, globalCommand } = this.cli;
+    const options = [...globalCommand.options, ...this.options];
+    for (const option of options) {
+      const value = parsedOptions[option.name.split(".")[0]];
+      if (option.required) {
+        const hasNegated = options.some((o) => o.negated && o.names.includes(option.name));
+        if (value === true || value === false && !hasNegated) {
+          throw new ClappError(`Option \`${option.rawName}\` requires a value.
+
+` + `Example: ${this.cli.name} ${this.rawName} ${option.rawName} <value>`);
+        }
+      }
+    }
+  }
+}
+
+class GlobalCommand extends Command {
+  constructor(cli) {
+    super("@@global@@", "", {}, cli);
+  }
+}
+var Command_default = Command;
+var codes = {
+  red: ["\x1B[31m", "\x1B[39m"],
+  green: ["\x1B[32m", "\x1B[39m"],
+  blue: ["\x1B[34m", "\x1B[39m"],
+  yellow: ["\x1B[33m", "\x1B[39m"],
+  cyan: ["\x1B[36m", "\x1B[39m"],
+  magenta: ["\x1B[35m", "\x1B[39m"],
+  white: ["\x1B[37m", "\x1B[39m"],
+  gray: ["\x1B[90m", "\x1B[39m"],
+  bgRed: ["\x1B[41m", "\x1B[49m"],
+  bgGreen: ["\x1B[42m", "\x1B[49m"],
+  bgBlue: ["\x1B[44m", "\x1B[49m"],
+  bgYellow: ["\x1B[43m", "\x1B[49m"],
+  bgCyan: ["\x1B[46m", "\x1B[49m"],
+  bgMagenta: ["\x1B[45m", "\x1B[49m"],
+  bold: ["\x1B[1m", "\x1B[22m"],
+  italic: ["\x1B[3m", "\x1B[23m"],
+  underline: ["\x1B[4m", "\x1B[24m"],
+  dim: ["\x1B[2m", "\x1B[22m"],
+  inverse: ["\x1B[7m", "\x1B[27m"],
+  hidden: ["\x1B[8m", "\x1B[28m"],
+  strikethrough: ["\x1B[9m", "\x1B[29m"]
+};
+var theme = {
+  primary: "blue",
+  secondary: "cyan",
+  success: "green",
+  warning: "yellow",
+  error: "red",
+  info: "magenta",
+  muted: "gray"
+};
+function detectColorSupport() {
+  return true;
+}
+function createStyler() {
+  const styler = {};
+  styler.supportsColor = detectColorSupport();
+  function createStyleFunction(styleName, styles = []) {
+    const styleList = styleName === "" ? [] : [...styles, styleName];
+    const fn = function(text) {
+      if (!styler.supportsColor)
+        return text;
+      let openCodes = "";
+      let closeCodes = "";
+      for (const style of styleList) {
+        if (style in theme && theme[style] in codes) {
+          const themeStyle = theme[style];
+          openCodes += codes[themeStyle][0];
+          closeCodes = codes[themeStyle][1] + closeCodes;
+        } else if (style in codes) {
+          openCodes += codes[style][0];
+          closeCodes = codes[style][1] + closeCodes;
+        }
+      }
+      return openCodes + text + closeCodes;
+    };
+    const allStyles2 = [...Object.keys(codes), ...Object.keys(theme)];
+    for (const style of allStyles2) {
+      if (!(style in fn)) {
+        Object.defineProperty(fn, style, {
+          get() {
+            return createStyleFunction(style, styleList);
+          }
+        });
+      }
+    }
+    return fn;
+  }
+  const allStyles = [...Object.keys(codes), ...Object.keys(theme)];
+  for (const style of allStyles) {
+    if (!(style in styler)) {
+      Object.defineProperty(styler, style, {
+        get() {
+          return createStyleFunction(style);
+        }
+      });
+    }
+  }
+  return styler;
+}
+var style = createStyler();
+class CLI extends EventEmitter {
+  name;
+  commands;
+  globalCommand;
+  matchedCommand;
+  matchedCommandName;
+  rawArgs;
+  args;
+  options;
+  showHelpOnExit;
+  showVersionOnExit;
+  enableDidYouMean = true;
+  signalHandlersSet = false;
+  isVerbose = false;
+  isQuiet = false;
+  isDebug = false;
+  isNoInteraction = false;
+  environment;
+  isDryRun = false;
+  isForce = false;
+  useEmoji = true;
+  theme;
+  isNoCache = false;
+  constructor(name = "") {
+    super();
+    this.name = name;
+    this.commands = [];
+    this.rawArgs = [];
+    this.args = [];
+    this.options = {};
+    this.globalCommand = new GlobalCommand(this);
+    this.globalCommand.usage("<command> [options]");
+  }
+  handleSignals(cleanup) {
+    if (this.signalHandlersSet) {
+      return this;
+    }
+    const handleSignal = async (signal) => {
+      console.log(`
+
+Received ${signal}, cleaning up...`);
+      if (cleanup) {
+        try {
+          await cleanup();
+        } catch (error) {
+          console.error("Error during cleanup:", error);
+        }
+      }
+      process5.exit(0);
+    };
+    process5.on("SIGINT", () => handleSignal("SIGINT"));
+    process5.on("SIGTERM", () => handleSignal("SIGTERM"));
+    this.signalHandlersSet = true;
+    return this;
+  }
+  didYouMean(enabled = true) {
+    this.enableDidYouMean = enabled;
+    return this;
+  }
+  verbose() {
+    this.globalCommand.option("-v, --verbose", "Enable verbose output");
+    return this;
+  }
+  quiet() {
+    this.globalCommand.option("-q, --quiet", "Suppress non-essential output");
+    return this;
+  }
+  debug() {
+    this.globalCommand.option("--debug", "Enable debug mode with detailed error information");
+    return this;
+  }
+  noInteraction() {
+    this.globalCommand.option("-n, --no-interaction", "Do not ask any interactive questions (for CI/CD)");
+    return this;
+  }
+  env() {
+    this.globalCommand.option("--env <environment>", "Target environment (e.g., production, staging, local)");
+    return this;
+  }
+  dryRun() {
+    this.globalCommand.option("--dry-run", "Preview actions without executing them");
+    return this;
+  }
+  force() {
+    this.globalCommand.option("-f, --force", "Skip confirmation prompts");
+    return this;
+  }
+  emoji() {
+    this.globalCommand.option("--no-emoji", "Disable emoji in output");
+    return this;
+  }
+  themes() {
+    this.globalCommand.option("--theme <theme>", "Color theme (default, dracula, nord, solarized, monokai)");
+    return this;
+  }
+  cache() {
+    this.globalCommand.option("--no-cache", "Disable caching");
+    return this;
+  }
+  usage(text) {
+    this.globalCommand.usage(text);
+    return this;
+  }
+  command(rawName, description, config) {
+    if (!config) {
+      config = {};
+    }
+    const command = new Command_default(rawName, description || "", config, this);
+    command.globalCommand = this.globalCommand;
+    this.commands.push(command);
+    return command;
+  }
+  option(rawName, description, config) {
+    this.globalCommand.option(rawName, description, config);
+    return this;
+  }
+  help(callback) {
+    this.globalCommand.option("-h, --help", "Display this message");
+    this.globalCommand.helpCallback = callback;
+    this.showHelpOnExit = true;
+    return this;
+  }
+  version(version, customFlags = "-v, --version") {
+    this.globalCommand.version(version, customFlags);
+    this.showVersionOnExit = true;
+    return this;
+  }
+  example(example) {
+    this.globalCommand.example(example);
+    return this;
+  }
+  outputHelp() {
+    if (this.matchedCommand) {
+      this.matchedCommand.outputHelp();
+    } else {
+      this.globalCommand.outputHelp();
+    }
+  }
+  outputVersion() {
+    this.globalCommand.outputVersion();
+  }
+  setParsedInfo({ args, options }, matchedCommand, matchedCommandName) {
+    this.args = args;
+    this.options = options;
+    if (matchedCommand) {
+      this.matchedCommand = matchedCommand;
+    }
+    if (matchedCommandName) {
+      this.matchedCommandName = matchedCommandName;
+    }
+    return this;
+  }
+  unsetMatchedCommand() {
+    this.matchedCommand = undefined;
+    this.matchedCommandName = undefined;
+  }
+  showCommandNotFound(input) {
+    console.log(style.red(`
+\u2717 Command "${input}" not found.
+`));
+    if (this.enableDidYouMean) {
+      const allCommandNames = [];
+      for (const command of this.commands) {
+        if (command.displayName) {
+          allCommandNames.push(command.displayName);
+        }
+        if (command.aliasNames) {
+          allCommandNames.push(...command.aliasNames);
+        }
+      }
+      const suggestions = findSimilarCommands(input, allCommandNames);
+      if (suggestions.length > 0) {
+        console.log(style.yellow("Did you mean one of these?"));
+        suggestions.forEach((cmd) => console.log(`  ${style.dim("\u2022")} ${this.name} ${cmd}`));
+        console.log("");
+      }
+    }
+    console.log(style.dim("Run"), `${this.name} --help`, style.dim("to see all available commands"));
+    process5.exit(1);
+  }
+  async parse(argv = processArgs2, options = {}) {
+    let { run = true, exitOnError = false } = options;
+    if (exitOnError) {
+      try {
+        return await this.parse(argv, { run });
+      } catch (err) {
+        this.handleUsageError(err);
+        throw err;
+      }
+    }
+    this.rawArgs = argv;
+    if (!this.name) {
+      this.name = argv[1] ? getFileName(argv[1]) : "cli";
+    }
+    let shouldParse = true;
+    const slicedArgv = argv.slice(2);
+    const candidateName = slicedArgv[0];
+    if (candidateName && !candidateName.startsWith("-")) {
+      for (const command of this.commands) {
+        if (command.isMatched(candidateName)) {
+          const parsed = this.mri(slicedArgv, command);
+          shouldParse = false;
+          const parsedInfo = {
+            ...parsed,
+            args: parsed.args.slice(1)
+          };
+          this.setParsedInfo(parsedInfo, command, candidateName);
+          this.emit(`command:${candidateName}`, command);
+          break;
+        }
+      }
+    }
+    if (shouldParse) {
+      for (const command of this.commands) {
+        if (command.name === "") {
+          shouldParse = false;
+          const parsed = this.mri(slicedArgv, command);
+          this.setParsedInfo(parsed, command);
+          this.emit(`command:!`, command);
+          break;
+        }
+      }
+    }
+    if (shouldParse) {
+      const parsed = this.mri(argv.slice(2));
+      this.setParsedInfo(parsed);
+    }
+    if (this.options.verbose) {
+      this.isVerbose = true;
+    }
+    if (this.options.quiet) {
+      this.isQuiet = true;
+    }
+    if (this.options.debug) {
+      this.isDebug = true;
+    }
+    if (this.options.noInteraction) {
+      this.isNoInteraction = true;
+    }
+    if (this.options.env) {
+      this.environment = String(this.options.env);
+    }
+    if (this.options.dryRun) {
+      this.isDryRun = true;
+    }
+    if (this.options.force) {
+      this.isForce = true;
+    }
+    if (this.options.noEmoji !== undefined) {
+      this.useEmoji = !this.options.noEmoji;
+    }
+    if (this.options.theme) {
+      this.theme = String(this.options.theme);
+    }
+    if (this.options.noCache !== undefined) {
+      this.isNoCache = Boolean(this.options.noCache);
+    }
+    if (this.options.help && this.showHelpOnExit) {
+      this.outputHelp();
+      run = false;
+      this.unsetMatchedCommand();
+    }
+    if (this.options.version && this.showVersionOnExit && this.matchedCommandName == null) {
+      this.outputVersion();
+      run = false;
+      this.unsetMatchedCommand();
+    }
+    const parsedArgv = { args: this.args, options: this.options };
+    if (run) {
+      await this.runMatchedCommand();
+    }
+    if (!this.matchedCommand && this.args[0]) {
+      this.emit("command:*");
+      const hasWildcardListener = this.listenerCount("command:*") > 0;
+      if (!hasWildcardListener) {
+        this.showCommandNotFound(this.args[0]);
+      }
+    }
+    return parsedArgv;
+  }
+  mri(argv, command) {
+    const cliOptions = [
+      ...this.globalCommand.options,
+      ...command ? command.options : []
+    ];
+    const mriOptions = getMriOptions(cliOptions);
+    let argsAfterDoubleDashes = [];
+    const doubleDashesIndex = argv.indexOf("--");
+    if (doubleDashesIndex > -1) {
+      argsAfterDoubleDashes = argv.slice(doubleDashesIndex + 1);
+      argv = argv.slice(0, doubleDashesIndex);
+    }
+    const raw = parseArgv(argv, mriOptions);
+    const parsed = { _: raw._ };
+    for (const name of Object.keys(raw)) {
+      if (name !== "_") {
+        parsed[camelcaseOptionName(name)] = raw[name];
+      }
+    }
+    const args = parsed._;
+    const options = {
+      "--": argsAfterDoubleDashes
+    };
+    const ignoreDefault = command && command.config.ignoreOptionDefaultValue ? command.config.ignoreOptionDefaultValue : this.globalCommand.config.ignoreOptionDefaultValue;
+    const transforms = Object.create(null);
+    for (const cliOption of cliOptions) {
+      if (!ignoreDefault && cliOption.config.default !== undefined) {
+        for (const name of cliOption.names) {
+          options[name] = cliOption.config.default;
+        }
+      }
+      if (Array.isArray(cliOption.config.type)) {
+        if (transforms[cliOption.name] === undefined) {
+          transforms[cliOption.name] = {
+            shouldTransform: true,
+            transformFunction: cliOption.config.type[0]
+          };
+        }
+      }
+    }
+    for (const key of Object.keys(parsed)) {
+      if (key !== "_") {
+        const keys = key.split(".");
+        setDotProp(options, keys, parsed[key]);
+        setByType(options, transforms);
+      }
+    }
+    return {
+      args,
+      options
+    };
+  }
+  async run(argv = processArgs2) {
+    return this.parse(argv, { run: true, exitOnError: true });
+  }
+  handleUsageError(err) {
+    const isClappError = !!err && typeof err === "object" && err.name === "ClappError";
+    const isUsage = isClappError && err.isUsageError !== false;
+    if (!isUsage)
+      return;
+    const e = err;
+    const raw = e.message ?? "command-line error";
+    const label = this.name ? `${this.name}: ` : "";
+    const suffix = /--help/.test(raw) ? "" : `
+Run \`${this.name ?? "cli"} --help\` for usage.`;
+    process5.stderr.write(`${label}${raw}${suffix}
+`);
+    process5.exit(e.exitCode ?? 2);
+  }
+  async runMatchedCommand() {
+    const { args, options, matchedCommand: command } = this;
+    if (!command || !command.commandAction)
+      return;
+    command.checkUnknownOptions();
+    command.checkOptionValue();
+    command.checkRequiredArgs();
+    const actionArgs = [];
+    command.args.forEach((arg, index) => {
+      if (arg.variadic) {
+        actionArgs.push(args.slice(index));
+      } else {
+        actionArgs.push(args[index]);
+      }
+    });
+    actionArgs.push(options);
+    const context = {
+      command,
+      args: actionArgs,
+      options
+    };
+    for (const hook of command.beforeHooks) {
+      await hook(context);
+    }
+    let actionResult;
+    const executeAction = async () => {
+      const result = command.commandAction.apply(this, actionArgs);
+      if (result instanceof Promise) {
+        actionResult = await result;
+      } else {
+        actionResult = result;
+      }
+      return actionResult;
+    };
+    if (command.middleware.length > 0) {
+      let index = 0;
+      const next = async () => {
+        if (index < command.middleware.length) {
+          const middleware = command.middleware[index++];
+          await middleware({ ...context, next });
+        } else {
+          await executeAction();
+        }
+      };
+      await next();
+    } else {
+      await executeAction();
+    }
+    for (const hook of command.afterHooks) {
+      await hook(context);
+    }
+    return actionResult;
+  }
+  removeSignalHandlers() {
+    if (!this.signalHandlersSet) {
+      return this;
+    }
+    process5.removeAllListeners("SIGINT");
+    process5.removeAllListeners("SIGTERM");
+    this.signalHandlersSet = false;
+    return this;
+  }
+  destroy() {
+    this.removeSignalHandlers();
+    this.commands = [];
+    this.rawArgs = [];
+    this.args = [];
+    this.options = {};
+    this.matchedCommand = undefined;
+    this.matchedCommandName = undefined;
+    this.removeAllListeners();
+  }
+}
+class CLICache {
+  cache;
+  enabled;
+  cleanupInterval = null;
+  hits = 0;
+  misses = 0;
+  constructor() {
+    this.cache = new Map;
+    this.enabled = true;
+    this.startCleanupInterval();
+  }
+  startCleanupInterval() {
+    if (this.cleanupInterval) {
+      return;
+    }
+    this.cleanupInterval = setInterval(() => {
+      this.cleanup();
+    }, 30000);
+    this.cleanupInterval.unref();
+  }
+  stopCleanup() {
+    if (this.cleanupInterval) {
+      clearInterval(this.cleanupInterval);
+      this.cleanupInterval = null;
+    }
+  }
+  isEnabled() {
+    return this.enabled;
+  }
+  get(key) {
+    if (!this.enabled) {
+      this.misses++;
+      return;
+    }
+    const entry = this.cache.get(key);
+    if (!entry) {
+      this.misses++;
+      return;
+    }
+    const now = Date.now();
+    if (now - entry.timestamp > entry.ttl) {
+      this.cache.delete(key);
+      this.misses++;
+      return;
+    }
+    this.hits++;
+    return entry.value;
+  }
+  set(key, value, ttl = 5000) {
+    if (!this.enabled) {
+      return;
+    }
+    this.cache.set(key, {
+      value,
+      timestamp: Date.now(),
+      ttl
+    });
+  }
+  has(key) {
+    if (!this.enabled) {
+      return false;
+    }
+    const entry = this.cache.get(key);
+    if (!entry) {
+      return false;
+    }
+    const now = Date.now();
+    if (now - entry.timestamp > entry.ttl) {
+      this.cache.delete(key);
+      return false;
+    }
+    return true;
+  }
+  delete(key) {
+    this.cache.delete(key);
+  }
+  clear() {
+    this.cache.clear();
+  }
+  disable() {
+    this.enabled = false;
+    this.clear();
+  }
+  enable() {
+    this.enabled = true;
+  }
+  stats() {
+    return {
+      size: this.cache.size,
+      enabled: this.enabled,
+      hits: this.hits,
+      misses: this.misses
+    };
+  }
+  resetStats() {
+    this.hits = 0;
+    this.misses = 0;
+  }
+  keys() {
+    return Array.from(this.cache.keys());
+  }
+  cleanup() {
+    const now = Date.now();
+    for (const [key, entry] of this.cache.entries()) {
+      if (now - entry.timestamp > entry.ttl) {
+        this.cache.delete(key);
+      }
+    }
+  }
+  destroy() {
+    this.stopCleanup();
+    this.clear();
+    this.resetStats();
+  }
+}
+var cliCache = new CLICache;
+function detectColorSupport2() {
+  if ("FORCE_COLOR" in process7.env) {
+    return process7.env.FORCE_COLOR !== "0";
+  }
+  if ("NO_COLOR" in process7.env || process7.env.TERM === "dumb") {
+    return false;
+  }
+  if (process7.platform === "win32") {
+    return true;
+  }
+  return tty.isatty(1) && tty.isatty(2);
+}
+var enabled = detectColorSupport2();
+function wrap(open, close) {
+  if (!enabled)
+    return (text) => text;
+  return (text) => open + text + close;
+}
+var reset = wrap("\x1B[0m", "\x1B[0m");
+var red = wrap("\x1B[31m", "\x1B[39m");
+var green = wrap("\x1B[32m", "\x1B[39m");
+var yellow = wrap("\x1B[33m", "\x1B[39m");
+var blue = wrap("\x1B[34m", "\x1B[39m");
+var magenta = wrap("\x1B[35m", "\x1B[39m");
+var cyan = wrap("\x1B[36m", "\x1B[39m");
+var white = wrap("\x1B[37m", "\x1B[39m");
+var gray = wrap("\x1B[90m", "\x1B[39m");
+var bold = wrap("\x1B[1m", "\x1B[22m");
+var italic = wrap("\x1B[3m", "\x1B[23m");
+var underline = wrap("\x1B[4m", "\x1B[24m");
+var dim = wrap("\x1B[2m", "\x1B[22m");
+var inverse = wrap("\x1B[7m", "\x1B[27m");
+var hidden = wrap("\x1B[8m", "\x1B[28m");
+var strikethrough = wrap("\x1B[9m", "\x1B[29m");
+var bgRed = wrap("\x1B[41m", "\x1B[49m");
+var bgGreen = wrap("\x1B[42m", "\x1B[49m");
+var bgYellow = wrap("\x1B[43m", "\x1B[49m");
+var bgBlue = wrap("\x1B[44m", "\x1B[49m");
+var bgMagenta = wrap("\x1B[45m", "\x1B[49m");
+var bgCyan = wrap("\x1B[46m", "\x1B[49m");
+var bgWhite = wrap("\x1B[47m", "\x1B[49m");
+var isColorSupported = enabled;
+var colors = {
+  reset,
+  red,
+  green,
+  yellow,
+  blue,
+  magenta,
+  cyan,
+  white,
+  gray,
+  bold,
+  italic,
+  underline,
+  dim,
+  inverse,
+  hidden,
+  strikethrough,
+  bgRed,
+  bgGreen,
+  bgYellow,
+  bgBlue,
+  bgMagenta,
+  bgCyan,
+  bgWhite,
+  isColorSupported
+};
+var colors_default = colors;
+var actions = ["up", "down", "left", "right", "space", "enter", "cancel"];
+var settings = {
+  actions: new Set(actions),
+  aliases: new Map([
+    ["k", "up"],
+    ["j", "down"],
+    ["h", "left"],
+    ["l", "right"],
+    ["\x03", "cancel"],
+    ["escape", "cancel"]
+  ]),
+  messages: {
+    cancel: "Canceled",
+    error: "Something went wrong"
+  }
+};
+function isActionKey(key, action) {
+  if (typeof key === "string") {
+    return settings.aliases.get(key) === action;
+  }
+  for (const value of key) {
+    if (value === undefined)
+      continue;
+    if (isActionKey(value, action)) {
+      return true;
+    }
+  }
+  return false;
+}
+function diffLines(a, b) {
+  if (a === b)
+    return [];
+  const aLines = a.split(`
+`);
+  const bLines = b.split(`
+`);
+  const diff = [];
+  for (let i = 0;i < Math.max(aLines.length, bLines.length); i++) {
+    if (aLines[i] !== bLines[i])
+      diff.push(i);
+  }
+  return diff;
+}
+var isWindows = process8.platform.startsWith("win");
+var CANCEL_SYMBOL = Symbol("clapp:cancel");
+function setRawMode(input, value) {
+  const i = input;
+  if (i.isTTY)
+    i.setRawMode(value);
+}
+function stripAnsi(str) {
+  return str.replace(/\x1b\[[0-9;]*m/g, "");
+}
+function stringWidth(str) {
+  return stripAnsi(str).length;
+}
+function wrapAnsi(text, columns, options) {
+  if (!columns || columns < 1)
+    return text;
+  const hard = options?.hard ?? false;
+  const trim = options?.trim ?? true;
+  const lines = text.split(`
+`);
+  const result = [];
+  for (const line of lines) {
+    if (stringWidth(line) <= columns) {
+      result.push(trim ? line.trimEnd() : line);
+      continue;
+    }
+    if (hard) {
+      let current = "";
+      let currentWidth = 0;
+      let i = 0;
+      while (i < line.length) {
+        const ansiMatch = line.slice(i).match(/^\x1b\[[0-9;]*m/);
+        if (ansiMatch) {
+          current += ansiMatch[0];
+          i += ansiMatch[0].length;
+          continue;
+        }
+        if (currentWidth >= columns) {
+          result.push(trim ? current.trimEnd() : current);
+          current = "";
+          currentWidth = 0;
+        }
+        current += line[i];
+        currentWidth++;
+        i++;
+      }
+      if (current) {
+        result.push(trim ? current.trimEnd() : current);
+      }
+    } else {
+      result.push(trim ? line.trimEnd() : line);
+    }
+  }
+  return result.join(`
+`);
+}
+
+class Prompt {
+  input;
+  output;
+  _abortSignal;
+  rl;
+  opts;
+  _render;
+  _track = false;
+  _prevFrame = "";
+  _subscribers = new Map;
+  _cursor = 0;
+  _manualLine = "";
+  state = "initial";
+  error = "";
+  value;
+  userInput = "";
+  constructor(options, trackValue = true) {
+    const { input = stdin2, output = stdout2, render, signal, ...opts } = options;
+    this.opts = opts;
+    this.onKeypress = this.onKeypress.bind(this);
+    this.close = this.close.bind(this);
+    this.render = this.render.bind(this);
+    this._render = render.bind(this);
+    this._track = trackValue;
+    this._abortSignal = signal;
+    this.input = input;
+    this.output = output;
+  }
+  unsubscribe() {
+    this._subscribers.clear();
+  }
+  setSubscriber(event, opts) {
+    const params = this._subscribers.get(event) ?? [];
+    params.push(opts);
+    this._subscribers.set(event, params);
+  }
+  on(event, cb) {
+    this.setSubscriber(event, { cb });
+    return this;
+  }
+  once(event, cb) {
+    this.setSubscriber(event, { cb, once: true });
+    return this;
+  }
+  emit(event, ...data) {
+    const cbs = this._subscribers.get(event) ?? [];
+    const cleanup = [];
+    for (const subscriber of cbs) {
+      subscriber.cb(...data);
+      if (subscriber.once) {
+        cleanup.push(() => cbs.splice(cbs.indexOf(subscriber), 1));
+      }
+    }
+    for (const cb of cleanup) {
+      cb();
+    }
+    return this;
+  }
+  prompt() {
+    return new Promise((resolve) => {
+      if (this._abortSignal) {
+        if (this._abortSignal.aborted) {
+          this.state = "cancel";
+          this.close();
+          return resolve(CANCEL_SYMBOL);
+        }
+        this._abortSignal.addEventListener("abort", () => {
+          this.state = "cancel";
+          this.close();
+        }, { once: true });
+      }
+      this.rl = readline2.createInterface({
+        input: this.input,
+        tabSize: 2,
+        prompt: "",
+        escapeCodeTimeout: 50,
+        terminal: true
+      });
+      this.rl.prompt();
+      if (this.opts.initialUserInput !== undefined) {
+        this._setUserInput(this.opts.initialUserInput, true);
+      }
+      this.input.on("keypress", this.onKeypress);
+      setRawMode(this.input, true);
+      this.output.on("resize", this.render);
+      this.render();
+      this.once("submit", () => {
+        this.output.write(cursor.show);
+        this.output.off("resize", this.render);
+        setRawMode(this.input, false);
+        resolve(this.value);
+      });
+      this.once("cancel", () => {
+        this.output.write(cursor.show);
+        this.output.off("resize", this.render);
+        setRawMode(this.input, false);
+        resolve(CANCEL_SYMBOL);
+      });
+    });
+  }
+  _isActionKey(char, _key) {
+    return char === "\t";
+  }
+  _setValue(value) {
+    this.value = value;
+    this.emit("value", this.value);
+  }
+  _setUserInput(value, write) {
+    this.userInput = value ?? "";
+    this.emit("userInput", this.userInput);
+    if (write && this._track && this.rl) {
+      this.rl.write(this.userInput);
+      this._cursor = this.rl.cursor;
+    }
+  }
+  onKeypress(char, key) {
+    if (this._track && key.name !== "return") {
+      if (key.name && this._isActionKey(char, key)) {
+        this.rl?.write(null, { ctrl: true, name: "h" });
+      }
+      this._cursor = this.rl?.cursor ?? 0;
+      const isSpecialKey = key.name === "tab" || key.name === "escape" || key.name === "backspace" || key.name === "delete" || key.name === "enter" || key.name === "return" || key.name && ["up", "down", "left", "right"].includes(key.name);
+      if (char && !isSpecialKey && char.length === 1 && char >= " ") {
+        this._manualLine += char;
+      } else if (key.name === "backspace" && this._manualLine.length > 0) {
+        this._manualLine = this._manualLine.slice(0, -1);
+      }
+      const effectiveLine = this._manualLine.length >= (this.rl?.line?.length || 0) ? this._manualLine : this.rl?.line;
+      this._setUserInput(effectiveLine);
+    }
+    if (this.state === "error") {
+      this.state = "active";
+      this.error = "";
+    }
+    if (key?.name) {
+      if (!this._track && settings.aliases.has(key.name)) {
+        this.emit("cursor", settings.aliases.get(key.name));
+      }
+      if (settings.actions.has(key.name)) {
+        this.emit("cursor", key.name);
+      }
+    }
+    if (char && (char.toLowerCase() === "y" || char.toLowerCase() === "n")) {
+      this.emit("confirm", char.toLowerCase() === "y");
+    }
+    this.emit("key", char?.toLowerCase(), key);
+    if (key?.name === "return") {
+      if (this.opts.validate) {
+        const problem = this.opts.validate(this.value);
+        if (problem) {
+          this.error = problem instanceof Error ? problem.message : problem;
+          this.state = "error";
+        }
+      }
+      if (this.state !== "error") {
+        this.state = "submit";
+      }
+    }
+    if (isActionKey([char, key?.name, key?.sequence], "cancel")) {
+      this.state = "cancel";
+    }
+    if (this.state === "submit" || this.state === "cancel") {
+      this.emit("finalize");
+    }
+    this.render();
+    if (this.state === "submit" || this.state === "cancel") {
+      this.close();
+    }
+  }
+  close() {
+    this.input.unpipe();
+    this.input.removeListener("keypress", this.onKeypress);
+    this.output.write(`
+`);
+    setRawMode(this.input, false);
+    this.rl?.close();
+    this.rl = undefined;
+    this.emit(`${this.state}`, this.value);
+    if (this.state === "cancel") {
+      setTimeout(() => {
+        this.unsubscribe();
+      }, 10);
+    } else {
+      this.unsubscribe();
+    }
+  }
+  restoreCursor() {
+    const lines = wrapAnsi(this._prevFrame, process9.stdout.columns, { hard: true, trim: false }).split(`
+`).length - 1;
+    this.output.write(cursor.move(-999, lines * -1));
+  }
+  render() {
+    const frame = wrapAnsi(this._render(this) ?? "", process9.stdout.columns, {
+      hard: true,
+      trim: false
+    });
+    if (frame === this._prevFrame) {
+      return;
+    }
+    if (this.state === "initial") {
+      this.output.write(cursor.hide);
+    } else {
+      const diff = diffLines(this._prevFrame, frame);
+      this.restoreCursor();
+      if (diff && diff?.length === 1) {
+        const diffLine = diff[0];
+        this.output.write(cursor.move(0, diffLine));
+        this.output.write(erase.lines(1));
+        const lines = frame.split(`
+`);
+        this.output.write(lines[diffLine]);
+        this._prevFrame = frame;
+        this.output.write(cursor.move(0, lines.length - diffLine - 1));
+        return;
+      }
+      if (diff && diff?.length > 1) {
+        const diffLine = diff[0];
+        this.output.write(cursor.move(0, diffLine));
+        this.output.write(erase.down());
+        const lines = frame.split(`
+`);
+        const newLines = lines.slice(diffLine);
+        this.output.write(newLines.join(`
+`));
+        this._prevFrame = frame;
+        return;
+      }
+      this.output.write(erase.down());
+    }
+    this.output.write(frame);
+    if (this.state === "initial") {
+      this.state = "active";
+    }
+    this._prevFrame = frame;
+  }
+}
+function getCursorForValue(selected, items) {
+  if (selected === undefined) {
+    return 0;
+  }
+  const currLength = items.length;
+  if (currLength === 0) {
+    return 0;
+  }
+  const index = items.findIndex((item) => item.value === selected);
+  return index !== -1 ? index : 0;
+}
+function defaultFilter(input, option) {
+  const label = option.label ?? String(option.value);
+  return label.toLowerCase().includes(input.toLowerCase());
+}
+function normalisedValue(multiple, values) {
+  if (!values) {
+    return;
+  }
+  if (multiple) {
+    return values;
+  }
+  return values[0];
+}
+
+class AutocompletePrompt extends Prompt {
+  filteredOptions;
+  multiple;
+  isNavigating = false;
+  selectedValues = [];
+  focusedValue;
+  #cursor = 0;
+  #lastUserInput = "";
+  #filterFn;
+  #options;
+  get cursor() {
+    return this.#cursor;
+  }
+  get userInputWithCursor() {
+    if (!this.userInput) {
+      return colors_default.inverse(colors_default.hidden("_"));
+    }
+    if (this._cursor >= this.userInput.length) {
+      return `${this.userInput}\u2588`;
+    }
+    const s1 = this.userInput.slice(0, this._cursor);
+    const [s2, ...s3] = this.userInput.slice(this._cursor);
+    return `${s1}${colors_default.inverse(s2)}${s3.join("")}`;
+  }
+  get options() {
+    if (typeof this.#options === "function") {
+      return this.#options();
+    }
+    return this.#options;
+  }
+  constructor(opts) {
+    super(opts);
+    this.#options = opts.options;
+    const options = this.options;
+    this.filteredOptions = [...options];
+    this.multiple = opts.multiple === true;
+    this.#filterFn = opts.filter ?? defaultFilter;
+    let initialValues;
+    if (opts.initialValue && Array.isArray(opts.initialValue)) {
+      if (this.multiple) {
+        initialValues = opts.initialValue;
+      } else {
+        initialValues = opts.initialValue.slice(0, 1);
+      }
+    } else {
+      if (!this.multiple && this.options.length > 0) {
+        initialValues = [this.options[0].value];
+      }
+    }
+    if (initialValues) {
+      for (const selectedValue of initialValues) {
+        const selectedIndex = options.findIndex((opt) => opt.value === selectedValue);
+        if (selectedIndex !== -1) {
+          this.toggleSelected(selectedValue);
+          this.#cursor = selectedIndex;
+        }
+      }
+    }
+    this.focusedValue = this.options[this.#cursor]?.value;
+    this.on("key", (char, key) => this.#onKey(char, key));
+    this.on("userInput", (value) => this.#onUserInputChanged(value));
+  }
+  _isActionKey(char, key) {
+    return char === "\t" || this.multiple && this.isNavigating && key.name === "space" && char !== undefined && char !== "";
+  }
+  #onKey(_char, key) {
+    const isUpKey = key.name === "up";
+    const isDownKey = key.name === "down";
+    const isReturnKey = key.name === "return";
+    if (isUpKey || isDownKey) {
+      this.#cursor = Math.max(0, Math.min(this.#cursor + (isUpKey ? -1 : 1), this.filteredOptions.length - 1));
+      this.focusedValue = this.filteredOptions[this.#cursor]?.value;
+      if (!this.multiple) {
+        this.selectedValues = [this.focusedValue];
+      }
+      this.isNavigating = true;
+    } else if (isReturnKey) {
+      this.value = normalisedValue(this.multiple, this.selectedValues);
+    } else {
+      if (this.multiple) {
+        if (this.focusedValue !== undefined && (key.name === "tab" || this.isNavigating && key.name === "space")) {
+          this.toggleSelected(this.focusedValue);
+        } else {
+          this.isNavigating = false;
+        }
+      } else {
+        if (this.focusedValue) {
+          this.selectedValues = [this.focusedValue];
+        }
+        this.isNavigating = false;
+      }
+    }
+  }
+  deselectAll() {
+    this.selectedValues = [];
+  }
+  toggleSelected(value) {
+    if (this.filteredOptions.length === 0) {
+      return;
+    }
+    if (this.multiple) {
+      if (this.selectedValues.includes(value)) {
+        this.selectedValues = this.selectedValues.filter((v) => v !== value);
+      } else {
+        this.selectedValues = [...this.selectedValues, value];
+      }
+    } else {
+      this.selectedValues = [value];
+    }
+  }
+  #onUserInputChanged(value) {
+    if (value !== this.#lastUserInput) {
+      this.#lastUserInput = value;
+      const options = this.options;
+      if (value) {
+        this.filteredOptions = options.filter((opt) => this.#filterFn(value, opt));
+      } else {
+        this.filteredOptions = [...options];
+      }
+      this.#cursor = getCursorForValue(this.focusedValue, this.filteredOptions);
+      this.focusedValue = this.filteredOptions[this.#cursor]?.value;
+      if (!this.multiple) {
+        if (this.focusedValue !== undefined) {
+          this.toggleSelected(this.focusedValue);
+        } else {
+          this.deselectAll();
+        }
+      }
+    }
+  }
+}
+class GroupMultiSelectPrompt extends Prompt {
+  options;
+  cursor = 0;
+  #selectableGroups;
+  getGroupItems(group) {
+    return this.options.filter((o) => o.group === group);
+  }
+  isGroupSelected(group) {
+    const items = this.getGroupItems(group);
+    const value = this.value;
+    if (value === undefined) {
+      return false;
+    }
+    return items.every((i) => value.includes(i.value));
+  }
+  toggleValue() {
+    const item = this.options[this.cursor];
+    if (this.value === undefined) {
+      this.value = [];
+    }
+    if (item.group === true) {
+      const group = String(item.value);
+      const groupedItems = this.getGroupItems(group);
+      if (this.isGroupSelected(group)) {
+        this.value = this.value.filter((v) => groupedItems.findIndex((i) => i.value === v) === -1);
+      } else {
+        this.value = [...this.value, ...groupedItems.map((i) => i.value)];
+      }
+      this.value = Array.from(new Set(this.value));
+    } else {
+      const selected = this.value.includes(item.value);
+      this.value = selected ? this.value.filter((v) => v !== item.value) : [...this.value, item.value];
+    }
+  }
+  constructor(opts) {
+    super(opts, false);
+    const { options } = opts;
+    this.#selectableGroups = opts.selectableGroups !== false;
+    this.options = Object.entries(options).flatMap(([key, option]) => [
+      { value: key, group: true, label: key },
+      ...option.map((opt) => ({ ...opt, group: key }))
+    ]);
+    this.value = [...opts.initialValues ?? []];
+    this.cursor = Math.max(this.options.findIndex(({ value }) => value === opts.cursorAt), this.#selectableGroups ? 0 : 1);
+    this.on("cursor", (key) => {
+      switch (key) {
+        case "left":
+        case "up": {
+          this.cursor = this.cursor === 0 ? this.options.length - 1 : this.cursor - 1;
+          const currentIsGroup = this.options[this.cursor]?.group === true;
+          if (!this.#selectableGroups && currentIsGroup) {
+            this.cursor = this.cursor === 0 ? this.options.length - 1 : this.cursor - 1;
+          }
+          break;
+        }
+        case "down":
+        case "right": {
+          this.cursor = this.cursor === this.options.length - 1 ? 0 : this.cursor + 1;
+          const currentIsGroup = this.options[this.cursor]?.group === true;
+          if (!this.#selectableGroups && currentIsGroup) {
+            this.cursor = this.cursor === this.options.length - 1 ? 0 : this.cursor + 1;
+          }
+          break;
+        }
+        case "space":
+          this.toggleValue();
+          break;
+      }
+    });
+  }
+}
+var unicode = isUnicodeSupported();
+var unicodeOr = (c, fallback) => unicode ? c : fallback;
+var S_STEP_ACTIVE = unicodeOr("\u25C6", "*");
+var S_STEP_CANCEL = unicodeOr("\u25A0", "x");
+var S_STEP_ERROR = unicodeOr("\u25B2", "x");
+var S_STEP_SUBMIT = unicodeOr("\u25C7", "o");
+var S_BAR_START = unicodeOr("\u250C", "T");
+var S_BAR = unicodeOr("\u2502", "|");
+var S_BAR_END = unicodeOr("\u2514", "\u2014");
+var S_RADIO_ACTIVE = unicodeOr("\u25CF", ">");
+var S_RADIO_INACTIVE = unicodeOr("\u25CB", " ");
+var S_CHECKBOX_ACTIVE = unicodeOr("\u25FB", "[\u2022]");
+var S_CHECKBOX_SELECTED = unicodeOr("\u25FC", "[+]");
+var S_CHECKBOX_INACTIVE = unicodeOr("\u25FB", "[ ]");
+var S_PASSWORD_MASK = unicodeOr("\u25AA", "\u2022");
+var S_BAR_H = unicodeOr("\u2500", "-");
+var S_CORNER_TOP_RIGHT = unicodeOr("\u256E", "+");
+var S_CONNECT_LEFT = unicodeOr("\u251C", "+");
+var S_CORNER_BOTTOM_RIGHT = unicodeOr("\u256F", "+");
+var S_INFO = unicodeOr("\u25CF", "\u2022");
+var S_SUCCESS = unicodeOr("\u25C6", "*");
+var S_WARN = unicodeOr("\u25B2", "!");
+var S_ERROR = unicodeOr("\u25A0", "x");
+var S_PROGRESS_CHAR = {
+  light: unicodeOr("\u2500", "-"),
+  heavy: unicodeOr("\u2501", "="),
+  block: unicodeOr("\u2588", "#")
+};
+function getPrefix() {
+  return `${colors_default.gray(S_BAR)}  `;
+}
+var prefix = getPrefix();
+
+// bin/cli.ts
+import { spawn as spawn2 } from "child_process";
+import { existsSync as existsSync6 } from "fs";
+import process6 from "process";
+
+// src/binary-resolver.ts
+import { existsSync as existsSync2 } from "fs";
+function resolveCraftBinary(explicit) {
+  if (explicit) {
+    if (!existsSync2(explicit)) {
+      throw new Error(`Custom Craft binary path not found: ${explicit}`);
+    }
+    return explicit;
+  }
+  const fromEnv = typeof process !== "undefined" ? process.env.CRAFT_BIN : undefined;
+  if (fromEnv) {
+    if (!existsSync2(fromEnv)) {
+      throw new Error(`CRAFT_BIN points to ${fromEnv}, which does not exist`);
+    }
+    return fromEnv;
+  }
+  return "craft";
+}
+function craftBinaryNotFoundMessage(triedPath) {
+  return [
+    `Craft native binary not found (tried "${triedPath}").`,
+    "",
+    "Craft ships through the pantry package registry. Install it with:",
+    "",
+    "  pantry install craft",
+    "",
+    "or, in a project, declare it in deps.yaml / pantry.jsonc and run",
+    "  pantry install",
+    "",
+    "See https://pantry.dev/quickstart for pantry installation instructions.",
+    "For monorepo development you can also point CRAFT_BIN at a local build."
+  ].join(`
+`);
+}
+// package.json
+var version = "0.0.49";
+
+// bin/cli.ts
+var cli = new CLI("craft");
+async function runCraftBinary(args) {
+  const craftPath = resolveCraftBinary();
+  return new Promise((resolve, reject) => {
+    const proc = spawn2(craftPath, args, { stdio: "inherit" });
+    proc.on("exit", (code) => {
+      if (code === 0 || code === null)
+        resolve();
+      else
+        reject(new Error(`Craft exited with code ${code}`));
+    });
+    proc.on("error", (error) => {
+      if (error.code === "ENOENT") {
+        reject(new Error(craftBinaryNotFoundMessage(craftPath)));
+        return;
+      }
+      reject(error);
+    });
+  });
+}
+function parseIntInRange(name, value, min, max) {
+  const n = typeof value === "number" ? value : Number.parseInt(String(value), 10);
+  if (!Number.isFinite(n) || !Number.isInteger(n)) {
+    throw new Error(`--${name} must be an integer (got: ${String(value)})`);
+  }
+  if (n < min || n > max) {
+    throw new Error(`--${name} must be between ${min} and ${max} (got: ${n})`);
+  }
+  return n;
+}
+function validateUrl(value) {
+  let parsed;
+  try {
+    parsed = new URL(value);
+  } catch {
+    throw new Error(`--url must be a valid URL (got: ${value})`);
+  }
+  const allowed = new Set(["http:", "https:", "file:", "data:"]);
+  if (!allowed.has(parsed.protocol)) {
+    throw new Error(`--url uses unsupported scheme "${parsed.protocol}"; allowed: ${[...allowed].join(", ")}`);
+  }
+  return parsed.toString();
+}
+cli.command("[url]", "Launch a Craft desktop app").option("--title <title>", "Window title").option("--width <width>", "Window width", { default: 800 }).option("--height <height>", "Window height", { default: 600 }).option("--x <x>", "Window x position").option("--y <y>", "Window y position").option("--frameless", "Frameless window").option("--transparent", "Transparent window").option("--always-on-top", "Always on top").option("--fullscreen", "Start in fullscreen").option("--dark-mode", "Enable dark mode").option("--hot-reload", "Enable hot reload").option("--dev-tools", "Enable developer tools").option("--no-resize", "Disable window resizing").example("craft http://localhost:3000").example('craft http://localhost:3000 --title "My App" --width 1200 --height 800').example("craft http://localhost:3000 --frameless --transparent --always-on-top").action(async (url, options) => {
+  const args = [];
+  try {
+    if (url) {
+      args.push("--url", validateUrl(url));
+    }
+    if (options?.title) {
+      const title = String(options.title);
+      if (title.length > 256)
+        throw new Error("--title must be 256 chars or fewer");
+      args.push("--title", title);
+    }
+    if (options?.width !== undefined)
+      args.push("--width", String(parseIntInRange("width", options.width, 100, 1e4)));
+    if (options?.height !== undefined)
+      args.push("--height", String(parseIntInRange("height", options.height, 100, 1e4)));
+    if (options?.x !== undefined)
+      args.push("--x", String(parseIntInRange("x", options.x, -1e5, 1e5)));
+    if (options?.y !== undefined)
+      args.push("--y", String(parseIntInRange("y", options.y, -1e5, 1e5)));
+    if (options?.frameless)
+      args.push("--frameless");
+    if (options?.transparent)
+      args.push("--transparent");
+    if (options?.alwaysOnTop)
+      args.push("--always-on-top");
+    if (options?.fullscreen)
+      args.push("--fullscreen");
+    if (options?.darkMode)
+      args.push("--dark-mode");
+    if (options?.hotReload)
+      args.push("--hot-reload");
+    if (options?.devTools)
+      args.push("--dev-tools");
+    if (options?.noResize)
+      args.push("--no-resize");
+  } catch (validationError) {
+    console.error(`Error: ${validationError.message}`);
+    process6.exit(2);
+  }
+  try {
+    await runCraftBinary(args);
+  } catch (error) {
+    console.error("Error:", error.message);
+    process6.exit(1);
+  }
+});
+cli.command("version", "Show the version").action(() => {
+  console.log(`v${version}`);
+});
+cli.command("build", "Build the Craft application").option("--release", "Build in release mode", { default: false }).option("--platform <platforms>", "Target platforms (ios,android,macos,windows,linux)", { default: "current" }).option("--config <path>", "Path to craft.config.ts").example("craft build").example("craft build --release").example("craft build --platform ios,android").example("craft build --platform macos,windows,linux").action(async (options) => {
+  const platforms = options?.platform === "current" ? [process6.platform === "darwin" ? "macos" : process6.platform === "win32" ? "windows" : "linux"] : options?.platform.split(",").map((p) => p.trim());
+  console.log(`
+\u26A1 Craft Build
+`);
+  console.log(`Platforms: ${platforms.join(", ")}`);
+  console.log(`Mode: ${options?.release ? "Release" : "Debug"}
+`);
+  const { existsSync: existsSync7 } = await import("fs");
+  const { spawn: spawn3 } = await import("child_process");
+  for (const platform of platforms) {
+    console.log(`\uD83D\uDCE6 Building for ${platform}...`);
+    try {
+      if (platform === "ios") {
+        if (process6.platform !== "darwin") {
+          console.log(`   \u26A0\uFE0F  iOS builds require macOS`);
+          continue;
+        }
+        const iosDir = "./ios";
+        if (existsSync7(iosDir)) {
+          const buildType = options?.release ? "Release" : "Debug";
+          await new Promise((resolve, reject) => {
+            const proc = spawn3("xcodebuild", [
+              "-project",
+              `${iosDir}/App.xcodeproj`,
+              "-scheme",
+              "App",
+              "-configuration",
+              buildType,
+              "-sdk",
+              "iphoneos",
+              "build"
+            ], { stdio: "inherit" });
+            proc.on("exit", (code) => code === 0 ? resolve() : reject(new Error(`Exit ${code}`)));
+            proc.on("error", reject);
+          });
+          console.log(`   \u2705 iOS ${buildType} build complete`);
+        } else {
+          console.log(`   \u26A0\uFE0F  No iOS project found. Run: craft ios init`);
+        }
+      } else if (platform === "android") {
+        const androidDir = "./android";
+        if (existsSync7(androidDir)) {
+          const task = options?.release ? "assembleRelease" : "assembleDebug";
+          await new Promise((resolve, reject) => {
+            const proc = spawn3("./gradlew", [task], {
+              cwd: androidDir,
+              stdio: "inherit"
+            });
+            proc.on("exit", (code) => code === 0 ? resolve() : reject(new Error(`Exit ${code}`)));
+            proc.on("error", reject);
+          });
+          console.log(`   \u2705 Android ${options?.release ? "Release" : "Debug"} build complete`);
+        } else {
+          console.log(`   \u26A0\uFE0F  No Android project found. Run: craft android init`);
+        }
+      } else if (platform === "macos" || platform === "windows" || platform === "linux") {
+        const zigDir = existsSync7("./packages/zig") ? "./packages/zig" : ".";
+        const optimizeFlag = options?.release ? "-Doptimize=ReleaseSafe" : "";
+        await new Promise((resolve, reject) => {
+          const args = ["build"];
+          if (optimizeFlag)
+            args.push(optimizeFlag);
+          const proc = spawn3("zig", args, {
+            cwd: zigDir,
+            stdio: "inherit"
+          });
+          proc.on("exit", (code) => code === 0 ? resolve() : reject(new Error(`Exit ${code}`)));
+          proc.on("error", reject);
+        });
+        console.log(`   \u2705 ${platform} build complete`);
+      }
+    } catch (error) {
+      console.error(`   \u274C ${platform} build failed: ${error.message}`);
+    }
+  }
+  console.log(`
+\u2728 Build complete
+`);
+});
+cli.command("dev [url]", "Launch in development mode with hot reload").option("--title <title>", "Window title", { default: "Craft Dev" }).option("--width <width>", "Window width", { default: 1200 }).option("--height <height>", "Window height", { default: 800 }).example("craft dev http://localhost:3000").action(async (url, options) => {
+  const args = [
+    "--url",
+    url || "http://localhost:3000",
+    "--title",
+    options?.title || "Craft Dev",
+    "--width",
+    String(options?.width || 1200),
+    "--height",
+    String(options?.height || 800),
+    "--hot-reload",
+    "--dev-tools",
+    "--dark-mode"
+  ];
+  try {
+    await runCraftBinary(args);
+  } catch (error) {
+    console.error("Error:", error.message);
+    process6.exit(1);
+  }
+});
+cli.command("package", "Create installers for your Craft application").option("--name <name>", "Application name").option("--version <version>", "Application version").option("--binary <path>", "Path to application binary").option("--description <text>", "Application description").option("--author <name>", "Author/Maintainer name").option("--bundle-id <id>", "Bundle identifier (macOS/iOS)").option("--out <dir>", "Output directory (default: ./dist)").option("--icon <path>", "Application icon path").option("--platforms <list>", "Comma-separated platforms (macos,windows,linux)").option("--config <path>", "Load config from JSON file").option("--dmg", "Create DMG installer (macOS)").option("--pkg", "Create PKG installer (macOS)").option("--msi", "Create MSI installer (Windows)").option("--zip", "Create ZIP archive (Windows)").option("--deb", "Create DEB package (Linux)").option("--rpm", "Create RPM package (Linux)").option("--appimage", "Create AppImage (Linux)").example('craft package --name "My App" --version "1.0.0" --binary ./build/myapp').example("craft package --config package.json").example('craft package --name "My App" --version "1.0.0" --binary ./build/myapp --platforms macos,windows,linux').action(async (options) => {
+  const packageModule = await Promise.resolve().then(() => (init_package(), exports_package));
+  const { packageApp: packageApp2 } = packageModule;
+  let config;
+  if (options?.config) {
+    if (!existsSync6(options.config)) {
+      console.error(`\u274C Config file not found: ${options.config}`);
+      process6.exit(1);
+    }
+    const configContent = await Bun.file(options.config).text();
+    config = JSON.parse(configContent);
+  } else {
+    if (!options?.name) {
+      console.error("\u274C --name is required");
+      process6.exit(1);
+    }
+    if (!options?.version) {
+      console.error("\u274C --version is required");
+      process6.exit(1);
+    }
+    if (!options?.binary) {
+      console.error("\u274C --binary is required");
+      process6.exit(1);
+    }
+    config = {
+      name: options.name,
+      version: options.version,
+      binaryPath: options.binary,
+      description: options.description,
+      author: options.author,
+      bundleId: options.bundleId,
+      outDir: options.out,
+      iconPath: options.icon,
+      platforms: options.platforms?.split(",")
+    };
+    if (options.dmg || options.pkg) {
+      config.macos = {
+        dmg: options.dmg,
+        pkg: options.pkg
+      };
+    }
+    if (options.msi || options.zip) {
+      config.windows = {
+        msi: options.msi,
+        zip: options.zip
+      };
+    }
+    if (options.deb || options.rpm || options.appimage) {
+      config.linux = {
+        deb: options.deb,
+        rpm: options.rpm,
+        appImage: options.appimage
+      };
+    }
+  }
+  console.log(`\uD83D\uDCE6 Craft Packaging Tool
+`);
+  console.log(`Application: ${config.name} v${config.version}`);
+  console.log(`Platforms: ${(config.platforms || ["current"]).join(", ")}
+`);
+  try {
+    const results = await packageApp2(config);
+    console.log(`
+\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501`);
+    console.log(`\uD83D\uDCCA Packaging Results
+`);
+    for (const result of results) {
+      const status = result.success ? "\u2705" : "\u274C";
+      const format = result.format.toUpperCase();
+      console.log(`${status} ${result.platform}/${format}`);
+      if (result.success && result.outputPath) {
+        console.log(`   \uD83D\uDCC1 ${result.outputPath}`);
+      } else if (result.error) {
+        console.log(`   \u26A0\uFE0F  ${result.error}`);
+      }
+    }
+    const successCount = results.filter((r) => r.success).length;
+    const totalCount = results.length;
+    console.log(`
+\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501`);
+    console.log(`
+\u2728 Complete: ${successCount}/${totalCount} packages created
+`);
+    process6.exit(successCount === totalCount ? 0 : 1);
+  } catch (error) {
+    console.error(`
+\u274C Error: ${error.message}
+`);
+    process6.exit(1);
+  }
+});
+cli.command("ios init <name>", "Initialize a new iOS project").option("--bundle-id <id>", "Bundle identifier (e.g., com.example.app)").option("--team-id <id>", "Apple Developer Team ID").option("-o, --output <dir>", "Output directory", { default: "./ios" }).example("craft ios init MyApp").example("craft ios init MyApp --bundle-id com.example.myapp").action(async (name, options) => {
+  const iosModule = await Promise.resolve().then(() => (init_src(), exports_src));
+  await iosModule.init({
+    name,
+    bundleId: options?.bundleId,
+    teamId: options?.teamId,
+    output: options?.output || "./ios"
+  });
+});
+cli.command("ios build", "Build iOS project").option("--html-path <path>", "Path to HTML file").option("-d, --dev-server <url>", "Development server URL").option("-o, --output <dir>", "iOS project directory", { default: "./ios" }).option("-w, --watch", "Watch for file changes and rebuild").example("craft ios build").example("craft ios build --html-path ./dist/index.html").example("craft ios build --dev-server http://localhost:3456").example("craft ios build --watch").action(async (options) => {
+  const iosModule = await Promise.resolve().then(() => (init_src(), exports_src));
+  const doBuild = async () => {
+    await iosModule.build({
+      htmlPath: options?.htmlPath,
+      devServer: options?.devServer,
+      output: options?.output || "./ios"
+    });
+  };
+  await doBuild();
+  if (options?.watch) {
+    console.log(`
+\uD83D\uDC40 Watching for changes...
+`);
+    const { watch } = await import("fs");
+    const { dirname: dirname3 } = await import("path");
+    const watchPath = options?.htmlPath ? dirname3(options.htmlPath) : ".";
+    watch(watchPath, { recursive: true }, async (event, filename) => {
+      if (filename && (filename.endsWith(".html") || filename.endsWith(".js") || filename.endsWith(".css"))) {
+        console.log(`
+\uD83D\uDCDD ${filename} changed, rebuilding...`);
+        await doBuild();
+      }
+    });
+    await new Promise(() => {});
+  }
+});
+cli.command("ios open", "Open iOS project in Xcode").option("-o, --output <dir>", "iOS project directory", { default: "./ios" }).action(async (options) => {
+  const iosModule = await Promise.resolve().then(() => (init_src(), exports_src));
+  await iosModule.open({
+    output: options?.output || "./ios"
+  });
+});
+cli.command("ios run", "Build and run on iOS device or simulator").option("-s, --simulator", "Run on simulator instead of device").option("-o, --output <dir>", "iOS project directory", { default: "./ios" }).example("craft ios run").example("craft ios run --simulator").action(async (options) => {
+  const iosModule = await Promise.resolve().then(() => (init_src(), exports_src));
+  await iosModule.run({
+    simulator: options?.simulator || false,
+    output: options?.output || "./ios"
+  });
+});
+cli.command("android init <name>", "Initialize a new Android project").option("--package <name>", "Package name (e.g., com.example.app)").option("-o, --output <dir>", "Output directory", { default: "./android" }).example("craft android init MyApp").example("craft android init MyApp --package com.example.myapp").action(async (name, options) => {
+  const androidModule = await Promise.resolve().then(() => (init_src2(), exports_src2));
+  await androidModule.init({
+    name,
+    packageName: options?.package,
+    output: options?.output || "./android"
+  });
+});
+cli.command("android build", "Build Android project").option("--html-path <path>", "Path to HTML file").option("-d, --dev-server <url>", "Development server URL").option("-o, --output <dir>", "Android project directory", { default: "./android" }).option("--release", "Build release APK").option("-w, --watch", "Watch for file changes and rebuild").example("craft android build").example("craft android build --release").example("craft android build --watch").action(async (options) => {
+  const androidModule = await Promise.resolve().then(() => (init_src2(), exports_src2));
+  const doBuild = async () => {
+    await androidModule.build({
+      htmlPath: options?.htmlPath,
+      devServer: options?.devServer,
+      output: options?.output || "./android",
+      release: options?.release || false
+    });
+  };
+  await doBuild();
+  if (options?.watch) {
+    console.log(`
+\uD83D\uDC40 Watching for changes...
+`);
+    const { watch } = await import("fs");
+    const { dirname: dirname3 } = await import("path");
+    const watchPath = options?.htmlPath ? dirname3(options.htmlPath) : ".";
+    watch(watchPath, { recursive: true }, async (event, filename) => {
+      if (filename && (filename.endsWith(".html") || filename.endsWith(".js") || filename.endsWith(".css"))) {
+        console.log(`
+\uD83D\uDCDD ${filename} changed, rebuilding...`);
+        await doBuild();
+      }
+    });
+    await new Promise(() => {});
+  }
+});
+cli.command("android open", "Open Android project in Android Studio").option("-o, --output <dir>", "Android project directory", { default: "./android" }).action(async (options) => {
+  const androidModule = await Promise.resolve().then(() => (init_src2(), exports_src2));
+  await androidModule.open({
+    output: options?.output || "./android"
+  });
+});
+cli.command("android run", "Build and run on Android device or emulator").option("-d, --device <id>", "Target device ID").option("-o, --output <dir>", "Android project directory", { default: "./android" }).example("craft android run").example("craft android run --device emulator-5554").action(async (options) => {
+  const androidModule = await Promise.resolve().then(() => (init_src2(), exports_src2));
+  await androidModule.run({
+    device: options?.device,
+    output: options?.output || "./android"
+  });
+});
+cli.command("preview [path]", "Preview app in browser before building native").option("-p, --port <port>", "Port to serve on", { default: 3456 }).option("--host <host>", "Host to bind to", { default: "localhost" }).example("craft preview ./dist").example("craft preview ./index.html --port 8080").action(async (path2, options) => {
+  const servePath = path2 || ".";
+  const port = options?.port || 3456;
+  const host = options?.host || "localhost";
+  console.log(`
+\uD83C\uDF10 Starting preview server...`);
+  console.log(`   Path: ${servePath}`);
+  console.log(`   URL: http://${host}:${port}
+`);
+  const { spawn: spawn3 } = await import("child_process");
+  const proc = spawn3("bunx", ["--bun", "serve", "-p", String(port), servePath], {
+    stdio: "inherit"
+  });
+  proc.on("error", () => {
+    console.log("Falling back to python http.server...");
+    spawn3("python3", ["-m", "http.server", String(port), "--directory", servePath], {
+      stdio: "inherit"
+    });
+  });
+});
+cli.command("publish", "Publish app to App Store or Play Store").option("--ios", "Publish to App Store (TestFlight)").option("--android", "Publish to Play Store").option("--api-key <path>", "App Store Connect API key path").option("--service-account <path>", "Google Play service account JSON").option("-o, --output <dir>", "Project directory", { default: "." }).example("craft publish --ios").example("craft publish --android").action(async (options) => {
+  const { existsSync: existsSync7 } = await import("fs");
+  const { join: join4 } = await import("path");
+  const { $: $3 } = await Promise.resolve(globalThis.Bun);
+  if (options?.ios) {
+    console.log(`
+\uD83D\uDCF1 Publishing to App Store (TestFlight)...
+`);
+    const iosDir = join4(options?.output || ".", "ios");
+    if (!existsSync7(iosDir)) {
+      console.error("\u274C No iOS project found. Run: craft ios init");
+      process6.exit(1);
+    }
+    console.log("1. Building archive...");
+    try {
+      await $3`cd ${iosDir} && xcodebuild -scheme App -configuration Release -archivePath ./build/App.xcarchive archive`;
+      console.log("\u2705 Archive created");
+      console.log("2. Exporting IPA...");
+      await $3`cd ${iosDir} && xcodebuild -exportArchive -archivePath ./build/App.xcarchive -exportPath ./build -exportOptionsPlist ExportOptions.plist`;
+      console.log("\u2705 IPA exported");
+      console.log("3. Uploading to TestFlight...");
+      if (options?.apiKey) {
+        await $3`xcrun altool --upload-app -f ${iosDir}/build/*.ipa --apiKey ${options.apiKey} --type ios`;
+      } else {
+        await $3`xcrun altool --upload-app -f ${iosDir}/build/*.ipa --type ios`;
+      }
+      console.log("\u2705 Uploaded to TestFlight!");
+    } catch (error) {
+      console.error("\u274C Publish failed. Make sure you have:");
+      console.error("   - Valid signing certificates");
+      console.error("   - App Store Connect API key (--api-key)");
+      console.error("   - ExportOptions.plist in your ios directory");
+    }
+  }
+  if (options?.android) {
+    console.log(`
+\uD83E\uDD16 Publishing to Play Store...
+`);
+    const androidDir = join4(options?.output || ".", "android");
+    if (!existsSync7(androidDir)) {
+      console.error("\u274C No Android project found. Run: craft android init");
+      process6.exit(1);
+    }
+    console.log("1. Building release AAB...");
+    try {
+      await $3`cd ${androidDir} && ./gradlew bundleRelease`;
+      console.log("\u2705 AAB created");
+      const aabPath = join4(androidDir, "app/build/outputs/bundle/release/app-release.aab");
+      if (options?.serviceAccount) {
+        console.log("2. Uploading to Play Store...");
+        console.log("\u26A0\uFE0F  Automatic Play Store upload requires fastlane or Google Play API integration.");
+        console.log(`   AAB file: ${aabPath}`);
+        console.log("   Upload manually via Play Console or use:");
+        console.log("   fastlane supply --aab " + aabPath);
+      } else {
+        console.log("\u2705 Release AAB ready:");
+        console.log(`   ${aabPath}`);
+        console.log("");
+        console.log("Upload manually via Play Console, or use fastlane:");
+        console.log("  fastlane supply --aab " + aabPath);
+      }
+    } catch (error) {
+      console.error("\u274C Build failed. Make sure you have:");
+      console.error("   - Valid signing key (keystore)");
+      console.error("   - Release signing config in build.gradle.kts");
+    }
+  }
+  if (!options?.ios && !options?.android) {
+    console.log("Please specify a platform:");
+    console.log("  craft publish --ios     # Publish to App Store");
+    console.log("  craft publish --android # Publish to Play Store");
+  }
+});
+cli.command("init <name>", "Initialize a new Craft project").option("--template <type>", "Project template (blank, tabs, drawer, dashboard, desktop, ios, android, all)", { default: "blank" }).option("--bundle-id <id>", "Bundle identifier for mobile").example("craft init MyApp").example("craft init MyApp --template tabs").example("craft init MyApp --template dashboard").example("craft init MyApp --template all").action(async (name, options) => {
+  console.log(`
+\u26A1 Creating new Craft project: ${name}
+`);
+  const template = options?.template || "blank";
+  const bundleId = options?.bundleId || `com.example.${name.toLowerCase().replace(/[^a-z0-9]/g, "")}`;
+  const appNameSlug = name.toLowerCase().replace(/[^a-z0-9]/g, "-");
+  const { mkdirSync: mkdirSync4, writeFileSync: writeFileSync4, existsSync: existsSync7, readdirSync: readdirSync3, readFileSync: readFileSync4, cpSync: cpSync2 } = await import("fs");
+  const { join: join4, dirname: dirname3 } = await import("path");
+  const replaceVars = (content) => {
+    return content.replace(/\{\{APP_NAME\}\}/g, name).replace(/\{\{APP_NAME_SLUG\}\}/g, appNameSlug).replace(/\{\{BUNDLE_ID\}\}/g, bundleId).replace(/\{\{AUTHOR\}\}/g, "Developer");
+  };
+  const copyTemplate = async (templateName, destDir) => {
+    const templateDir = join4(import.meta.dir, "templates/projects", templateName);
+    if (!existsSync7(templateDir)) {
+      console.log(`   \u26A0\uFE0F  Template '${templateName}' not found, using blank template`);
+      return false;
+    }
+    const copyRecursive = (src, dest) => {
+      if (!existsSync7(dest)) {
+        mkdirSync4(dest, { recursive: true });
+      }
+      const entries = readdirSync3(src, { withFileTypes: true });
+      for (const entry of entries) {
+        const srcPath = join4(src, entry.name);
+        const destPath = join4(dest, entry.name);
+        if (entry.isDirectory()) {
+          copyRecursive(srcPath, destPath);
+        } else {
+          const content = readFileSync4(srcPath, "utf-8");
+          const processedContent = replaceVars(content);
+          writeFileSync4(destPath, processedContent);
+        }
+      }
+    };
+    copyRecursive(templateDir, destDir);
+    return true;
+  };
+  if (["blank", "tabs", "drawer", "dashboard"].includes(template)) {
+    console.log(`\uD83D\uDCC1 Creating ${template} project from template...`);
+    if (!existsSync7(name)) {
+      mkdirSync4(name, { recursive: true });
+    }
+    const copied = await copyTemplate(template, name);
+    if (!copied) {
+      mkdirSync4(join4(name, "src"), { recursive: true });
+      writeFileSync4(join4(name, "index.html"), replaceVars(`<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>{{APP_NAME}}</title>
+</head>
+<body>
+  <div id="app">
+    <h1>{{APP_NAME}}</h1>
+    <p>Built with Craft</p>
+  </div>
+</body>
+</html>`));
+      writeFileSync4(join4(name, "package.json"), replaceVars(JSON.stringify({
+        name: "{{APP_NAME_SLUG}}",
+        version: "1.0.0",
+        private: true,
+        type: "module",
+        scripts: {
+          dev: "craft dev",
+          build: "craft build"
+        },
+        dependencies: {
+          "craft-native": "workspace:*"
+        }
+      }, null, 2)));
+    }
+    console.log(`\u2705 ${template} project created`);
+  }
+  if (template === "desktop" || template === "all") {
+    console.log("\uD83D\uDCC1 Creating desktop project structure...");
+    if (!existsSync7(name)) {
+      mkdirSync4(name, { recursive: true });
+    }
+    const configContent = `import type { CraftConfig } from 'craft-native'
+
+export default {
+  name: '${name}',
+  window: {
+    title: '${name}',
+    width: 1200,
+    height: 800,
+    darkMode: true,
+  },
+} satisfies CraftConfig
+`;
+    writeFileSync4(`${name}/craft.config.ts`, configContent);
+    const htmlContent = `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>${name}</title>
+  <style>
+    * { margin: 0; padding: 0; box-sizing: border-box; }
+    body {
+      font-family: -apple-system, system-ui, sans-serif;
+      background: #1a1a2e;
+      color: white;
+      min-height: 100vh;
+      display: flex;
+      justify-content: center;
+      align-items: center;
+    }
+    .container { text-align: center; }
+    h1 { font-size: 3rem; margin-bottom: 1rem; }
+    p { opacity: 0.7; }
+  </style>
+</head>
+<body>
+  <div class="container">
+    <h1>\u26A1 ${name}</h1>
+    <p>Built with Craft</p>
+  </div>
+</body>
+</html>
+`;
+    writeFileSync4(`${name}/index.html`, htmlContent);
+    const packageJson = {
+      name: appNameSlug,
+      version: "0.1.0",
+      private: true,
+      scripts: {
+        dev: "craft dev http://localhost:3000",
+        build: "craft build",
+        "ios:init": "craft ios init " + name,
+        "ios:build": "craft ios build",
+        "ios:open": "craft ios open"
+      },
+      devDependencies: {
+        "craft-native": "*"
+      }
+    };
+    writeFileSync4(`${name}/package.json`, JSON.stringify(packageJson, null, 2));
+    console.log("\u2705 Desktop project created");
+  }
+  if (template === "ios" || template === "all") {
+    console.log("\uD83D\uDCF1 Creating iOS project...");
+    const iosModule = await Promise.resolve().then(() => (init_src(), exports_src));
+    await iosModule.init({
+      name,
+      bundleId: options?.bundleId,
+      output: template === "all" ? `${name}/ios` : "./ios"
+    });
+    console.log("\u2705 iOS project created");
+  }
+  if (template === "android" || template === "all") {
+    console.log("\uD83E\uDD16 Creating Android project...");
+    const androidModule = await Promise.resolve().then(() => (init_src2(), exports_src2));
+    await androidModule.init({
+      name,
+      packageName: options?.bundleId,
+      output: template === "all" ? `${name}/android` : "./android"
+    });
+    console.log("\u2705 Android project created");
+  }
+  console.log("");
+  console.log("Next steps:");
+  console.log(`  cd ${name}`);
+  console.log("  bun install");
+  if (template === "desktop" || template === "all") {
+    console.log("  craft dev http://localhost:3000");
+  }
+  if (template === "ios" || template === "all") {
+    console.log("  craft ios build");
+    console.log("  craft ios open");
+  }
+  if (template === "android" || template === "all") {
+    console.log("  craft android build");
+    console.log("  craft android open");
+  }
+  console.log("");
+});
+cli.version(version);
+cli.help();
+cli.parse();