@apps-in-toss/cli 1.14.1 → 2.0.1

package/dist/index.js

@@ -46,10 +46,10 @@ var require_picocolors = __commonJS({
   "../../../.yarn/cache/picocolors-npm-1.1.1-b0c45fa35e-e2e3e8170a.zip/node_modules/picocolors/picocolors.js"(exports, module) {
     "use strict";
     init_esm_shims();
-    var p5 = process || {};
-    var argv = p5.argv || [];
-    var env = p5.env || {};
-    var isColorSupported = !(!!env.NO_COLOR || argv.includes("--no-color")) && (!!env.FORCE_COLOR || argv.includes("--color") || p5.platform === "win32" || (p5.stdout || {}).isTTY && env.TERM !== "dumb" || !!env.CI);
+    var p8 = process || {};
+    var argv = p8.argv || [];
+    var env = p8.env || {};
+    var isColorSupported = !(!!env.NO_COLOR || argv.includes("--no-color")) && (!!env.FORCE_COLOR || argv.includes("--color") || p8.platform === "win32" || (p8.stdout || {}).isTTY && env.TERM !== "dumb" || !!env.CI);
     var formatter = (open, close, replace = open) => (input) => {
       let string = "" + input, index = string.indexOf(close, open.length);
       return ~index ? open + replaceClose(string, close, replace, index) + close : open + string + close;
@@ -233,9 +233,9 @@ var require_ms = __commonJS({
   }
 });
 
-// ../../../.yarn/__virtual__/debug-virtual-5f733de965/0/cache/debug-npm-4.4.0-f1ca372596-db94f1a182.zip/node_modules/debug/src/common.js
+// ../../../.yarn/__virtual__/debug-virtual-4a69f763f8/0/cache/debug-npm-4.4.0-f1ca372596-db94f1a182.zip/node_modules/debug/src/common.js
 var require_common = __commonJS({
-  "../../../.yarn/__virtual__/debug-virtual-5f733de965/0/cache/debug-npm-4.4.0-f1ca372596-db94f1a182.zip/node_modules/debug/src/common.js"(exports, module) {
+  "../../../.yarn/__virtual__/debug-virtual-4a69f763f8/0/cache/debug-npm-4.4.0-f1ca372596-db94f1a182.zip/node_modules/debug/src/common.js"(exports, module) {
     "use strict";
     init_esm_shims();
     function setup(env) {
@@ -412,9 +412,9 @@ var require_common = __commonJS({
   }
 });
 
-// ../../../.yarn/__virtual__/debug-virtual-5f733de965/0/cache/debug-npm-4.4.0-f1ca372596-db94f1a182.zip/node_modules/debug/src/browser.js
+// ../../../.yarn/__virtual__/debug-virtual-4a69f763f8/0/cache/debug-npm-4.4.0-f1ca372596-db94f1a182.zip/node_modules/debug/src/browser.js
 var require_browser = __commonJS({
-  "../../../.yarn/__virtual__/debug-virtual-5f733de965/0/cache/debug-npm-4.4.0-f1ca372596-db94f1a182.zip/node_modules/debug/src/browser.js"(exports, module) {
+  "../../../.yarn/__virtual__/debug-virtual-4a69f763f8/0/cache/debug-npm-4.4.0-f1ca372596-db94f1a182.zip/node_modules/debug/src/browser.js"(exports, module) {
     "use strict";
     init_esm_shims();
     exports.formatArgs = formatArgs;
@@ -584,15 +584,15 @@ var require_browser = __commonJS({
   }
 });
 
-// ../../../.yarn/__virtual__/debug-virtual-5f733de965/0/cache/debug-npm-4.4.0-f1ca372596-db94f1a182.zip/node_modules/debug/src/node.js
+// ../../../.yarn/__virtual__/debug-virtual-4a69f763f8/0/cache/debug-npm-4.4.0-f1ca372596-db94f1a182.zip/node_modules/debug/src/node.js
 var require_node = __commonJS({
-  "../../../.yarn/__virtual__/debug-virtual-5f733de965/0/cache/debug-npm-4.4.0-f1ca372596-db94f1a182.zip/node_modules/debug/src/node.js"(exports, module) {
+  "../../../.yarn/__virtual__/debug-virtual-4a69f763f8/0/cache/debug-npm-4.4.0-f1ca372596-db94f1a182.zip/node_modules/debug/src/node.js"(exports, module) {
     "use strict";
     init_esm_shims();
     var tty = __require("tty");
     var util = __require("util");
     exports.init = init;
-    exports.log = log4;
+    exports.log = log7;
     exports.formatArgs = formatArgs;
     exports.save = save;
     exports.load = load;
@@ -727,7 +727,7 @@ var require_node = __commonJS({
       }
       return (/* @__PURE__ */ new Date()).toISOString() + " ";
     }
-    function log4(...args) {
+    function log7(...args) {
       return process.stderr.write(util.formatWithOptions(exports.inspectOpts, ...args) + "\n");
     }
     function save(namespaces) {
@@ -760,9 +760,9 @@ var require_node = __commonJS({
   }
 });
 
-// ../../../.yarn/__virtual__/debug-virtual-5f733de965/0/cache/debug-npm-4.4.0-f1ca372596-db94f1a182.zip/node_modules/debug/src/index.js
+// ../../../.yarn/__virtual__/debug-virtual-4a69f763f8/0/cache/debug-npm-4.4.0-f1ca372596-db94f1a182.zip/node_modules/debug/src/index.js
 var require_src = __commonJS({
-  "../../../.yarn/__virtual__/debug-virtual-5f733de965/0/cache/debug-npm-4.4.0-f1ca372596-db94f1a182.zip/node_modules/debug/src/index.js"(exports, module) {
+  "../../../.yarn/__virtual__/debug-virtual-4a69f763f8/0/cache/debug-npm-4.4.0-f1ca372596-db94f1a182.zip/node_modules/debug/src/index.js"(exports, module) {
     "use strict";
     init_esm_shims();
     if (typeof process === "undefined" || process.type === "renderer" || process.browser === true || process.__nwjs) {
@@ -777,37 +777,687 @@ var require_src = __commonJS({
 init_esm_shims();
 import { Cli, Builtins } from "clipanion";
 
+// src/BuildCommand.ts
+init_esm_shims();
+import path7 from "path";
+import * as p3 from "@clack/prompts";
+import { getPackageRoot } from "@granite-js/utils";
+import { Command } from "clipanion";
+
+// src/build/buildArtifact/index.ts
+init_esm_shims();
+import * as p2 from "@clack/prompts";
+
+// src/build/buildArtifact/defaultBuildDeps.ts
+init_esm_shims();
+import { collectDependencyVersions, createArtifact, getSdkVersion } from "@apps-in-toss/plugins";
+import { uuidv7 } from "uuidv7";
+
+// src/build/buildArtifact/utils.ts
+init_esm_shims();
+import fs from "fs/promises";
+import path from "path";
+
+// src/build/buildArtifact/constants.ts
+init_esm_shims();
+var RUNTIME_BUILD_DEFINITIONS = [
+  { runtimeVersion: "0.84.0" },
+  { runtimeVersion: "0.72.6", configTargetVersion: "0.72.6" }
+];
+var DIST_DIRECTORY = "dist";
+
+// src/build/buildArtifact/utils.ts
+async function clearBuildCache(packageRoot) {
+  await fs.rm(path.join(packageRoot, DIST_DIRECTORY), { recursive: true, force: true });
+}
+async function ensureGraniteConfigExists(graniteConfigPath) {
+  try {
+    await fs.access(graniteConfigPath);
+  } catch {
+    throw new Error(`Cannot find granite config: ${graniteConfigPath}`);
+  }
+}
+async function resolveArtifactOptions(strategy, context) {
+  if (strategy.getArtifactOptions == null) {
+    return { isGame: context.appType === "game" };
+  }
+  return strategy.getArtifactOptions(context);
+}
+async function readAppManifest(appJsonPath) {
+  const appJsonRaw = await fs.readFile(appJsonPath, "utf8");
+  const appJson = JSON.parse(appJsonRaw);
+  if (typeof appJson.appName !== "string" || appJson.appName.length === 0) {
+    throw new Error(`Invalid appName in ${appJsonPath}`);
+  }
+  return {
+    appName: appJson.appName,
+    appType: appJson.appType ?? void 0
+  };
+}
+
+// src/build/resolveBuildStrategy.ts
+init_esm_shims();
+import fs2 from "fs/promises";
+async function resolveBuildStrategy(graniteConfigPath, strategyFactories) {
+  const graniteConfigSource = await fs2.readFile(graniteConfigPath, "utf8");
+  for (const strategy of strategyFactories) {
+    if (await strategy.match({ graniteConfigPath, graniteConfigSource })) {
+      return strategy;
+    }
+  }
+  throw new Error(`Cannot resolve build strategy: ${graniteConfigPath}`);
+}
+
+// src/build/buildArtifact/defaultBuildDeps.ts
+var defaultBuildDeps = {
+  clearBuildCache,
+  resolveStrategy: resolveBuildStrategy,
+  collectDependencyVersions,
+  createArtifact,
+  getSdkVersion,
+  generateDeploymentId: uuidv7
+};
+
+// src/build/buildArtifact/prepareArtifact.ts
+init_esm_shims();
+import path2 from "path";
+
+// src/utils/constants.ts
+init_esm_shims();
+var APP_MANIFEST_NAME = "app.json";
+var DEFAULT_API_BASE_URL = "https://apps-in-toss.toss.im/console";
+
+// src/build/buildArtifact/prepareArtifact.ts
+async function prepareArtifact({
+  packageRoot,
+  preparation,
+  services
+}) {
+  const appJsonPath = path2.join(packageRoot, ".granite", APP_MANIFEST_NAME);
+  const { appName, appType } = await readAppManifest(appJsonPath);
+  const outfile = path2.join(packageRoot, `${appName}.ait`);
+  const { dependencies, devDependencies } = await services.collectDependencyVersions(packageRoot);
+  const sdkVersion = services.getSdkVersion();
+  const artifactOptions = await resolveArtifactOptions(preparation.strategy, {
+    ...preparation.context,
+    appName,
+    appType
+  });
+  return {
+    appJsonPath,
+    appName,
+    appType,
+    outfile,
+    sdkVersion,
+    dependencies,
+    devDependencies,
+    artifactOptions
+  };
+}
+
+// src/build/buildArtifact/prepareBuild.ts
+init_esm_shims();
+import path3 from "path";
+async function prepareBuild({
+  packageRoot,
+  services,
+  strategies
+}) {
+  const graniteConfigPath = path3.join(packageRoot, "granite.config.ts");
+  const deploymentId = services.generateDeploymentId();
+  await ensureGraniteConfigExists(graniteConfigPath);
+  await services.clearBuildCache(packageRoot);
+  const strategy = await services.resolveStrategy(graniteConfigPath, strategies);
+  const buildInput = {
+    runtimeBuildDefinitions: RUNTIME_BUILD_DEFINITIONS
+  };
+  if (buildInput.runtimeBuildDefinitions.length === 0) {
+    throw new Error("No runtime build definitions provided");
+  }
+  return {
+    strategy,
+    context: { packageRoot, deploymentId, graniteConfigPath },
+    buildInput,
+    primaryRuntimeVersion: buildInput.runtimeBuildDefinitions[0].runtimeVersion
+  };
+}
+
+// src/build/buildArtifact/runStrategyBuild.ts
+init_esm_shims();
+import * as p from "@clack/prompts";
+async function runStrategyBuild(preparation) {
+  const buildResults = await preparation.strategy.build(preparation.buildInput, preparation.context);
+  const bundleFiles = [];
+  for (let i = 0; i < buildResults.length; i++) {
+    const result = buildResults[i];
+    bundleFiles.push(...result.bundleFiles);
+    p.log.step(`[${i + 1}/${buildResults.length}] Built for RN ${result.runtimeVersion}`);
+  }
+  return bundleFiles;
+}
+
+// src/build/RNBuildStrategy.ts
+init_esm_shims();
+import fs4 from "fs/promises";
+import path5 from "path";
+import { getPackageManager } from "@apps-in-toss/web-config";
+import { execa } from "execa";
+
+// src/build/createRuntimeBundleFiles.ts
+init_esm_shims();
+import fs3 from "fs/promises";
+import path4 from "path";
+async function createRuntimeBundleFiles({
+  packageRoot,
+  runtimeVersion,
+  bundleOutputDir
+}) {
+  const distPath = path4.isAbsolute(bundleOutputDir) ? bundleOutputDir : path4.join(packageRoot, bundleOutputDir);
+  const platforms = ["ios", "android"];
+  const runtimeName = runtimeVersion.replace(/\./g, "_");
+  const bundleFiles = [];
+  for (const platform of platforms) {
+    const sourceJsPath = path4.join(distPath, `bundle.${platform}.js`);
+    const sourceMapPath = path4.join(distPath, `bundle.${platform}.js.map`);
+    const targetJsPath = path4.join(distPath, `bundle.${platform}.${runtimeName}.js`);
+    const targetMapPath = path4.join(distPath, `bundle.${platform}.${runtimeName}.js.map`);
+    await copyRequiredFile(sourceJsPath, targetJsPath);
+    await copyRequiredFile(sourceMapPath, targetMapPath);
+    bundleFiles.push({
+      path: targetJsPath,
+      platform,
+      runtimeVersion
+    });
+    bundleFiles.push({
+      path: targetMapPath,
+      platform,
+      runtimeVersion
+    });
+  }
+  return bundleFiles;
+}
+async function copyRequiredFile(sourcePath, targetPath) {
+  try {
+    await fs3.copyFile(sourcePath, targetPath);
+  } catch {
+    throw new Error(`Missing build output file: ${sourcePath}`);
+  }
+}
+
+// src/utils/injectAppsInTossTarget.ts
+init_esm_shims();
+
+// src/MigrateCommand/codemod/index.ts
+init_esm_shims();
+
+// src/MigrateCommand/codemod/transform.ts
+init_esm_shims();
+import jscodeshift from "jscodeshift";
+function transform(source, { transformers: transformers2, options = {} }) {
+  const j = jscodeshift.withParser("tsx");
+  const report = [];
+  const stats = /* @__PURE__ */ new Map();
+  const context = {
+    j,
+    jscodeshift: j,
+    stats: (name, quantity = 1) => {
+      if (quantity === 0) {
+        return;
+      }
+      stats.set(name, (stats.get(name) ?? 0) + quantity);
+    },
+    report: (message) => {
+      report.push(message);
+    }
+  };
+  const root = transformers2.reduce((root2, transformer) => transformer(root2, context, options), j(source));
+  return root.toSource();
+}
+
+// src/utils/injectAppsInTossTarget.ts
+var TARGET_IMPORTS = [
+  { source: "@apps-in-toss/framework/plugins", importName: "appsInToss" },
+  { source: "@apps-in-toss/plugins", importName: "appsInToss" },
+  { source: "@apps-in-toss/framework/internal", importName: "appsInTossHost" },
+  { source: "@apps-in-toss/plugins/internal", importName: "appsInTossHost" }
+];
+function createAppsInTossTargetTransformer(stats) {
+  return (root, { j }, options) => {
+    const fileName = options?.fileName ?? "<unknown>";
+    const targetVersion = options?.targetVersion;
+    if (typeof targetVersion !== "string" || targetVersion.length === 0) {
+      return root;
+    }
+    const localNames = /* @__PURE__ */ new Set();
+    let warnedForUnsupportedArg = false;
+    for (const targetImport of TARGET_IMPORTS) {
+      root.find(j.ImportDeclaration, {
+        source: { value: targetImport.source }
+      }).forEach((importPath) => {
+        for (const specifier of importPath.node.specifiers ?? []) {
+          if (specifier.type === "ImportSpecifier" && specifier.imported.type === "Identifier" && specifier.imported.name === targetImport.importName) {
+            localNames.add(specifier.local?.name ?? targetImport.importName);
+          }
+        }
+      });
+    }
+    if (localNames.size === 0) {
+      return root;
+    }
+    root.find(j.CallExpression).forEach((path13) => {
+      const callee = path13.node.callee;
+      if (!j.Identifier.check(callee) || !localNames.has(callee.name)) {
+        return;
+      }
+      stats.matchedCallCount += 1;
+      const firstArg = path13.node.arguments[0];
+      if (firstArg == null) {
+        path13.node.arguments = [
+          j.objectExpression([j.objectProperty(j.identifier("target"), j.stringLiteral(targetVersion))])
+        ];
+        stats.updatedCallCount += 1;
+        return;
+      }
+      if (!j.ObjectExpression.check(firstArg)) {
+        stats.hadUnsupportedArgument = true;
+        if (!warnedForUnsupportedArg) {
+          warnedForUnsupportedArg = true;
+          options?.onUnsupportedArgument?.(fileName);
+        }
+        return;
+      }
+      const targetProp = firstArg.properties.find((property) => {
+        if (!j.ObjectProperty.check(property)) {
+          return false;
+        }
+        if (j.Identifier.check(property.key)) {
+          return property.key.name === "target";
+        }
+        return j.StringLiteral.check(property.key) && property.key.value === "target";
+      });
+      if (targetProp != null && j.ObjectProperty.check(targetProp)) {
+        targetProp.value = j.stringLiteral(targetVersion);
+        stats.updatedCallCount += 1;
+        return;
+      }
+      firstArg.properties.unshift(j.objectProperty(j.identifier("target"), j.stringLiteral(targetVersion)));
+      stats.updatedCallCount += 1;
+    });
+    return root;
+  };
+}
+function injectAppsInTossTargetWithResult(source, options) {
+  const stats = {
+    matchedCallCount: 0,
+    updatedCallCount: 0,
+    hadUnsupportedArgument: false
+  };
+  const code = transform(source, {
+    transformers: [createAppsInTossTargetTransformer(stats)],
+    options
+  });
+  return {
+    code,
+    ...stats
+  };
+}
+
+// src/build/RNBuildStrategy.ts
+var GRANITE_DIRECTORY = ".granite";
+var TEMP_CONFIG_FILE_PREFIX = ".ait-runtime";
+var BUNDLE_OUTPUT_DIRECTORY = "dist";
+var RNBuildStrategy = class {
+  name = "rn";
+  match(context) {
+    return true;
+  }
+  async build(input, context) {
+    const results = [];
+    const graniteCommand = resolveGraniteCommand();
+    for (const definition of input.runtimeBuildDefinitions) {
+      const graniteBuildArgs = await resolveGraniteBuildArgs(definition, context);
+      const tempConfigPath = graniteBuildArgs.tempConfigPath;
+      const commandArgs = [...graniteCommand.prefixArgs, "build", ...graniteBuildArgs.args];
+      try {
+        await execa(graniteCommand.executable, commandArgs, {
+          cwd: context.packageRoot,
+          env: {
+            ...process.env,
+            AIT_DEPLOYMENT_ID: context.deploymentId
+          },
+          stdio: "inherit"
+        });
+      } catch (error) {
+        throw new Error(`granite build failed: ${graniteCommand.executable} ${commandArgs.join(" ")}`, {
+          cause: error
+        });
+      } finally {
+        if (tempConfigPath != null) {
+          await fs4.rm(tempConfigPath, { force: true });
+        }
+      }
+      results.push({
+        runtimeVersion: definition.runtimeVersion,
+        bundleFiles: await createRuntimeBundleFiles({
+          packageRoot: context.packageRoot,
+          runtimeVersion: definition.runtimeVersion,
+          bundleOutputDir: BUNDLE_OUTPUT_DIRECTORY
+        })
+      });
+    }
+    return results;
+  }
+  async getArtifactOptions(context) {
+    return {
+      isGame: context.appType === "game"
+    };
+  }
+};
+function resolveGraniteCommand() {
+  const { packageManager } = getPackageManager({ isExecutor: true });
+  return {
+    executable: packageManager,
+    prefixArgs: ["granite"]
+  };
+}
+async function resolveGraniteBuildArgs(definition, context) {
+  if (definition.configTargetVersion == null) {
+    return { args: ["--no-cache"] };
+  }
+  const targetVersion = definition.configTargetVersion;
+  const tempConfigRelativePath = createTempConfigRelativePath(targetVersion);
+  const tempConfigPath = path5.join(context.packageRoot, tempConfigRelativePath);
+  try {
+    await writeRuntimeConfig(context.graniteConfigPath, tempConfigPath, targetVersion);
+    return {
+      args: ["--config", tempConfigRelativePath, "--no-cache"],
+      tempConfigPath
+    };
+  } catch {
+    return { args: ["--no-cache"], tempConfigPath };
+  }
+}
+function createTempConfigRelativePath(targetVersion) {
+  const runtimeName = targetVersion.replace(/\./g, "_");
+  return path5.join(GRANITE_DIRECTORY, `${TEMP_CONFIG_FILE_PREFIX}-${runtimeName}.config.ts`);
+}
+async function writeRuntimeConfig(graniteConfigPath, tempConfigPath, targetVersion) {
+  const source = await fs4.readFile(graniteConfigPath, "utf8");
+  const transformed = injectAppsInTossTargetWithResult(source, {
+    fileName: graniteConfigPath,
+    targetVersion
+  });
+  if (transformed.matchedCallCount === 0) {
+    throw new Error(
+      `Cannot inject target (${targetVersion}) into ${graniteConfigPath}: appsInToss/appsInTossHost call not found`
+    );
+  }
+  if (transformed.hadUnsupportedArgument) {
+    throw new Error(
+      `Cannot inject target (${targetVersion}) into ${graniteConfigPath}: unsupported plugin argument shape detected`
+    );
+  }
+  await fs4.mkdir(path5.dirname(tempConfigPath), { recursive: true });
+  await fs4.writeFile(tempConfigPath, transformed.code, "utf8");
+}
+
+// src/build/WebBuildStrategy.ts
+init_esm_shims();
+import fs5 from "fs/promises";
+import { createRequire as createRequireFromPath } from "module";
+import path6 from "path";
+import { babelBuild, getPackageManager as getPackageManager2, loadConfig, writeBundle } from "@apps-in-toss/web-config";
+import { execa as execa2 } from "execa";
+var APP_MANIFEST_NAME2 = "app.json";
+var WebBuildStrategy = class {
+  name = "web";
+  config;
+  prepared = false;
+  match({ graniteConfigSource }) {
+    return graniteConfigSource.includes("@apps-in-toss/web-framework");
+  }
+  async build(input, context) {
+    const config = await this.ensurePrepared(context);
+    const results = [];
+    for (const definition of input.runtimeBuildDefinitions) {
+      for (const platform of ["ios", "android"]) {
+        const buildResult = await buildRuntimeBundle({
+          config,
+          runtimeVersion: definition.runtimeVersion,
+          deploymentId: context.deploymentId,
+          packageRoot: context.packageRoot,
+          platform
+        });
+        await writeBundle(buildResult, { platform, config, cwd: context.packageRoot });
+      }
+      results.push({
+        runtimeVersion: definition.runtimeVersion,
+        bundleFiles: await createRuntimeBundleFiles({
+          packageRoot: context.packageRoot,
+          runtimeVersion: definition.runtimeVersion,
+          bundleOutputDir: config.outdir
+        })
+      });
+    }
+    return results;
+  }
+  async getArtifactOptions(context) {
+    const config = await this.ensureConfig();
+    const isGame = config.webViewProps?.type === "game";
+    const extra = {
+      brand: config.brand,
+      ...config.navigationBar != null ? { navigationBar: config.navigationBar } : {},
+      ...config.webViewProps != null ? { webViewProps: config.webViewProps } : {}
+    };
+    const webDistDir = path6.join(context.packageRoot, config.outdir, "web");
+    const additionalFilesToZip = await getWebDistFiles(webDistDir);
+    return { isGame, additionalFilesToZip, extra };
+  }
+  async ensurePrepared(context) {
+    const config = await this.ensureConfig();
+    if (this.prepared) {
+      return config;
+    }
+    const outdir = path6.join(context.packageRoot, config.outdir);
+    const webDistDir = path6.join(context.packageRoot, config.outdir, "web");
+    try {
+      const files = await fs5.readdir(webDistDir);
+      if (files.includes("index.html")) {
+        await this.writeAppJson(context);
+        this.prepared = true;
+        return config;
+      }
+    } catch {
+    }
+    const { packageManager } = getPackageManager2({ isExecutor: true });
+    await fs5.rm(outdir, { recursive: true, force: true });
+    await execa2(packageManager, config.web.commands.build.split(" "), {
+      cwd: context.packageRoot,
+      stdio: "inherit",
+      shell: true
+    });
+    await fs5.mkdir(webDistDir, { recursive: true });
+    const items = await fs5.readdir(outdir);
+    for (const item of items) {
+      const src = path6.join(outdir, item);
+      const dest = path6.join(webDistDir, item);
+      if (src === webDistDir) {
+        continue;
+      }
+      await fs5.rename(src, dest);
+    }
+    const webDistFiles = await fs5.readdir(webDistDir);
+    if (webDistFiles.length === 0) {
+      throw new Error(
+        `Web build output is empty. Check that your outdir path and web.commands.build output path match in granite.config.ts.`
+      );
+    }
+    if (!webDistFiles.includes("index.html")) {
+      throw new Error(
+        `Web build output requires ${config.outdir}/web/index.html. Currently only CSR / SSG environments are supported.`
+      );
+    }
+    await this.writeAppJson(context);
+    this.prepared = true;
+    return config;
+  }
+  async writeAppJson(context) {
+    const config = await this.ensureConfig();
+    const graniteDir = path6.join(context.packageRoot, ".granite");
+    await fs5.mkdir(graniteDir, { recursive: true });
+    await fs5.writeFile(
+      path6.join(graniteDir, APP_MANIFEST_NAME2),
+      JSON.stringify(
+        {
+          appName: config.appName,
+          permissions: config.permissions
+        },
+        null,
+        2
+      ),
+      "utf8"
+    );
+  }
+  async ensureConfig() {
+    if (this.config) {
+      return this.config;
+    }
+    const config = await loadConfig();
+    if (!config) {
+      throw new Error("Cannot find granite config");
+    }
+    this.config = config;
+    return this.config;
+  }
+};
+async function buildRuntimeBundle({
+  config,
+  runtimeVersion,
+  deploymentId,
+  packageRoot,
+  platform = "ios"
+}) {
+  const buildNumber = getBuildNumber();
+  const projectRequire = createRequireFromPath(path6.join(packageRoot, "package.json"));
+  const rnSuffix = runtimeVersion.startsWith("0.72") ? "rn72" : "rn84";
+  const prebuiltPath = projectRequire.resolve(`@apps-in-toss/web-framework/prebuilt/prod/${platform}/${rnSuffix}`);
+  return babelBuild({
+    config,
+    platform,
+    buildNumber,
+    deploymentId,
+    prebuiltPath
+  });
+}
+function getBuildNumber() {
+  const date = /* @__PURE__ */ new Date();
+  const year = date.getFullYear();
+  const month = String(date.getMonth() + 1).padStart(2, "0");
+  const day = String(date.getDate()).padStart(2, "0");
+  const hours = String(date.getHours()).padStart(2, "0");
+  const minutes = String(date.getMinutes()).padStart(2, "0");
+  const seconds = String(date.getSeconds()).padStart(2, "0");
+  return `${year}${month}${day}${hours}${minutes}${seconds}`;
+}
+async function getWebDistFiles(webDistDir) {
+  const additionalFilesToZip = [];
+  try {
+    const allFiles = await fs5.readdir(webDistDir, { recursive: true });
+    const webFiles = await Promise.all(
+      allFiles.map(async (file) => {
+        const filePath = path6.join(webDistDir, String(file));
+        const stat = await fs5.stat(filePath);
+        return stat.isFile() ? String(file) : null;
+      })
+    ).then((files) => files.filter((file) => file !== null));
+    additionalFilesToZip.push(
+      ...webFiles.map((file) => ({
+        path: path6.join(webDistDir, file),
+        name: path6.join("web", file)
+      }))
+    );
+  } catch {
+  }
+  return additionalFilesToZip;
+}
+
+// src/build/buildArtifact/index.ts
+async function buildArtifact(packageRoot, deps = {}) {
+  const services = {
+    ...defaultBuildDeps,
+    ...deps
+  };
+  const strategies = [new WebBuildStrategy(), new RNBuildStrategy()];
+  const preparation = await prepareBuild({ packageRoot, services, strategies });
+  const bundleFiles = await runStrategyBuild(preparation);
+  const artifact = await prepareArtifact({ packageRoot, preparation, services });
+  p2.log.step("Creating .ait artifact...");
+  await services.createArtifact({
+    reactNativeVersion: preparation.primaryRuntimeVersion,
+    sdkVersion: artifact.sdkVersion,
+    isGame: artifact.artifactOptions.isGame,
+    isWeb: preparation.strategy.name === "web",
+    appJsonPath: artifact.appJsonPath,
+    deploymentId: preparation.context.deploymentId,
+    packageJson: {
+      dependencies: artifact.dependencies,
+      devDependencies: artifact.devDependencies
+    },
+    bundleFiles,
+    outfile: artifact.outfile,
+    ...artifact.artifactOptions.additionalFilesToZip != null ? { additionalFilesToZip: artifact.artifactOptions.additionalFilesToZip } : {},
+    ...artifact.artifactOptions.extra != null ? { extra: artifact.artifactOptions.extra } : {}
+  });
+  return { outfile: artifact.outfile, deploymentId: preparation.context.deploymentId };
+}
+
+// src/BuildCommand.ts
+var BuildCommand = class extends Command {
+  static paths = [["build"]];
+  static usage = Command.Usage({
+    category: "Build",
+    description: "Build Apps In Toss artifact",
+    examples: [["Build artifact", "ait build"]]
+  });
+  async execute() {
+    const packageRoot = getPackageRoot();
+    const buildResult = await buildArtifact(packageRoot);
+    p3.log.success(`AIT build completed (${path7.basename(buildResult.outfile)})`);
+    p3.log.info(`deploymentId: ${buildResult.deploymentId}`);
+  }
+};
+
 // src/DeployCommand.ts
 init_esm_shims();
 var import_picocolors = __toESM(require_picocolors(), 1);
 import assert from "assert";
-import fs3 from "fs";
-import path2 from "path";
+import fs8 from "fs";
+import path9 from "path";
 import { AppsInTossBundle } from "@apps-in-toss/ait-format";
-import * as p from "@clack/prompts";
-import { getPackageRoot, readZipContent } from "@granite-js/utils";
-import { Command, Option } from "clipanion";
+import * as p4 from "@clack/prompts";
+import { getPackageRoot as getPackageRoot2, readZipContent } from "@granite-js/utils";
+import { Command as Command2, Option } from "clipanion";
 
 // src/utils/TokenStorage.ts
 init_esm_shims();
-import fs from "fs";
+import fs6 from "fs";
 import os from "os";
-import path from "path";
+import path8 from "path";
 var TokenStorage = class {
   static get path() {
     const home = os.homedir();
-    const dir = path.join(home, ".ait");
-    if (!fs.existsSync(dir)) {
-      fs.mkdirSync(dir, { recursive: true });
+    const dir = path8.join(home, ".ait");
+    if (!fs6.existsSync(dir)) {
+      fs6.mkdirSync(dir, { recursive: true });
     }
-    return path.join(dir, "credentials");
+    return path8.join(dir, "credentials");
   }
   static read() {
     const file = this.path;
-    if (!fs.existsSync(file)) {
+    if (!fs6.existsSync(file)) {
       return {};
     }
-    const raw = fs.readFileSync(file, "utf8");
+    const raw = fs6.readFileSync(file, "utf8");
     try {
       const parsed = JSON.parse(raw);
       if (parsed && typeof parsed === "object") {
@@ -820,7 +1470,7 @@ var TokenStorage = class {
   static write(map) {
     const file = this.path;
     const content = JSON.stringify(map, null, 2);
-    fs.writeFileSync(file, content, { encoding: "utf8" });
+    fs6.writeFileSync(file, content, { encoding: "utf8" });
   }
   static set(workspace, token) {
     const creds = this.read();
@@ -842,15 +1492,10 @@ var TokenStorage = class {
   }
 };
 
-// src/utils/constants.ts
-init_esm_shims();
-var APP_MANIFEST_NAME = "app.json";
-var DEFAULT_API_BASE_URL = "https://apps-in-toss.toss.im/console";
-
 // src/utils/upload.ts
 init_esm_shims();
 var import_debug2 = __toESM(require_src(), 1);
-import fs2 from "fs";
+import fs7 from "fs";
 
 // src/utils/flowAsync.ts
 init_esm_shims();
@@ -942,8 +1587,8 @@ function uploadArtifactToRemote() {
   return async (params) => {
     const { config, output } = params;
     debug2("uploadArtifactToRemote", config, output);
-    const stat = await fs2.promises.stat(config.artifactPath);
-    const stream = fs2.createReadStream(config.artifactPath);
+    const stat = await fs7.promises.stat(config.artifactPath);
+    const stream = fs7.createReadStream(config.artifactPath);
     const response = await fetch(output.uploadUrl, {
       method: "PUT",
       headers: {
@@ -1013,7 +1658,7 @@ function checkBundleStatus(delayMs = 1e4, maxRetries = 10) {
 }
 
 // src/DeployCommand.ts
-var DeployCommand = class extends Command {
+var DeployCommand = class extends Command2 {
   static paths = [["deploy"]];
   apiKey = Option.String("--api-key", {
     required: false,
@@ -1043,15 +1688,15 @@ var DeployCommand = class extends Command {
     const baseUrl = this.baseUrl;
     const profile = this.profile || this.workspace || "default";
     if (this.workspace) {
-      p.log.warn("(deprecated) --workspace \uC635\uC158\uC740 \uC774\uC81C \uC0AC\uC6A9\uD558\uC9C0 \uC54A\uC544\uC694. \uC774 \uC635\uC158 \uB300\uC2E0 --profile \uC635\uC158\uC744 \uC0AC\uC6A9\uD574\uC8FC\uC138\uC694.");
+      p4.log.warn("(deprecated) --workspace \uC635\uC158\uC740 \uC774\uC81C \uC0AC\uC6A9\uD558\uC9C0 \uC54A\uC544\uC694. \uC774 \uC635\uC158 \uB300\uC2E0 --profile \uC635\uC158\uC744 \uC0AC\uC6A9\uD574\uC8FC\uC138\uC694.");
     }
     const apiKey = await this.getApiKey(profile);
-    if (p.isCancel(apiKey)) {
+    if (p4.isCancel(apiKey)) {
       return;
     }
     try {
       const resolvedArtifactPath = this.getArtifactPath(this.location);
-      const buffer = fs3.readFileSync(resolvedArtifactPath);
+      const buffer = fs8.readFileSync(resolvedArtifactPath);
       const format = AppsInTossBundle.detect(buffer);
       const { appName, deploymentId } = await (async () => {
         if (format === AppsInTossBundle.Format.AIT) {
@@ -1083,7 +1728,7 @@ var DeployCommand = class extends Command {
           baseUrl
         });
       } else {
-        await p.tasks([
+        await p4.tasks([
           {
             title: `${colorAppName} \uC571 \uBC30\uD3EC \uC911...`,
             task: async () => {
@@ -1121,7 +1766,7 @@ var DeployCommand = class extends Command {
       this.context.stdout.write(`${result}
 `);
     } else {
-      p.note(this.decorate(result, import_picocolors.default.green));
+      p4.note(this.decorate(result, import_picocolors.default.green));
     }
   }
   printError(error) {
@@ -1129,7 +1774,7 @@ var DeployCommand = class extends Command {
       this.context.stdout.write(`${error.message}
 `);
     } else {
-      p.log.error(error.message);
+      p4.log.error(error.message);
     }
   }
   async getApiKey(profile) {
@@ -1137,7 +1782,7 @@ var DeployCommand = class extends Command {
     if (token) {
       return token;
     }
-    return await p.password({
+    return await p4.password({
       message: "\uC571\uC778\uD1A0\uC2A4 \uBC30\uD3EC API \uD0A4\uB97C \uC785\uB825\uD574\uC8FC\uC138\uC694",
       validate: (value) => {
         if (value.length === 0) {
@@ -1152,24 +1797,24 @@ var DeployCommand = class extends Command {
       if (!location.endsWith(".ait")) {
         throw new Error("\uBC30\uD3EC\uD560 \uD30C\uC77C\uC740 .ait \uD655\uC7A5\uC790\uC5EC\uC57C \uD569\uB2C8\uB2E4.");
       }
-      return path2.resolve(location);
+      return path9.resolve(location);
     }
-    const packageRoot = getPackageRoot();
-    const artifactFile = fs3.readdirSync(packageRoot).find((file) => file.endsWith(".ait"));
+    const packageRoot = getPackageRoot2();
+    const artifactFile = fs8.readdirSync(packageRoot).find((file) => file.endsWith(".ait"));
     if (!artifactFile) {
       throw new Error("\uBC30\uD3EC\uD560 .ait \uD30C\uC77C\uC744 \uCC3E\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4.");
     }
-    return path2.resolve(packageRoot, artifactFile);
+    return path9.resolve(packageRoot, artifactFile);
   }
 };
 
 // src/InitCommand.ts
 init_esm_shims();
-import fs4 from "fs";
-import path3 from "path";
-import * as p2 from "@clack/prompts";
-import { getPackageRoot as getPackageRoot2 } from "@granite-js/utils";
-import { Command as Command2, Option as Option2 } from "clipanion";
+import fs9 from "fs";
+import path10 from "path";
+import * as p5 from "@clack/prompts";
+import { getPackageRoot as getPackageRoot3 } from "@granite-js/utils";
+import { Command as Command3, Option as Option2 } from "clipanion";
 
 // ../../../.yarn/cache/es-toolkit-npm-1.32.0-019fc7c155-56ba965570.zip/node_modules/es-toolkit/dist/index.mjs
 init_esm_shims();
@@ -1266,7 +1911,7 @@ function transformTemplate(templateString, values) {
 
 // src/InitCommand.ts
 async function templateWebFramework({ appName, cwd, skipInput }) {
-  const packageJson = await fs4.promises.readFile(path3.join(cwd, "package.json"), {
+  const packageJson = await fs9.promises.readFile(path10.join(cwd, "package.json"), {
     encoding: "utf-8"
   });
   const scripts = JSON.parse(packageJson);
@@ -1275,25 +1920,25 @@ async function templateWebFramework({ appName, cwd, skipInput }) {
     build: scripts?.scripts?.build
   };
   scripts.scripts.dev = "granite dev";
-  scripts.scripts.build = "granite build";
+  scripts.scripts.build = "ait build";
   scripts.scripts.deploy = "ait deploy";
-  await fs4.promises.writeFile(path3.join(cwd, "package.json"), JSON.stringify(scripts, null, 2), {
+  await fs9.promises.writeFile(path10.join(cwd, "package.json"), JSON.stringify(scripts, null, 2), {
     encoding: "utf-8"
   });
-  p2.log.step(".gitignore \uD30C\uC77C\uC744 \uC5C5\uB370\uC774\uD2B8\uD558\uB294 \uC911...");
-  await fs4.promises.appendFile(path3.join(cwd, ".gitignore"), "\n.granite\n");
+  p5.log.step(".gitignore \uD30C\uC77C\uC744 \uC5C5\uB370\uC774\uD2B8\uD558\uB294 \uC911...");
+  await fs9.promises.appendFile(path10.join(cwd, ".gitignore"), "\n.granite\n");
   const placeholder = {
     dev: originalScripts.dev === "granite dev" ? "" : originalScripts.dev,
-    build: originalScripts.build === "granite build" ? "" : originalScripts.build
+    build: originalScripts.build === "ait build" ? "" : originalScripts.build
   };
-  const scriptInputs = skipInput ? placeholder : await p2.group(
+  const scriptInputs = skipInput ? placeholder : await p5.group(
     {
-      dev: () => p2.text({
+      dev: () => p5.text({
         message: "\uC6F9 \uBC88\uB4E4\uB7EC\uC758 dev \uBA85\uB839\uC5B4\uB97C \uC785\uB825\uD574\uC8FC\uC138\uC694.",
         defaultValue: placeholder.dev,
         placeholder: placeholder.dev
       }),
-      build: () => p2.text({
+      build: () => p5.text({
         message: "\uC6F9 \uBC88\uB4E4\uB7EC\uC758 build \uBA85\uB839\uC5B4\uB97C \uC785\uB825\uD574\uC8FC\uC138\uC694.",
         defaultValue: placeholder.build,
         placeholder: placeholder.build
@@ -1301,44 +1946,56 @@ async function templateWebFramework({ appName, cwd, skipInput }) {
     },
     {
       onCancel: () => {
-        p2.cancel("\uCD08\uAE30\uD654\uAC00 \uCDE8\uC18C\uB418\uC5C8\uC2B5\uB2C8\uB2E4");
+        p5.cancel("\uCD08\uAE30\uD654\uAC00 \uCDE8\uC18C\uB418\uC5C8\uC2B5\uB2C8\uB2E4");
       }
     }
   );
-  p2.log.step("granite.config.ts \uD30C\uC77C\uC744 \uC0DD\uC131\uD558\uB294 \uC911...");
-  const webPort = skipInput ? "5173" : await p2.text({
+  p5.log.step("granite.config.ts \uD30C\uC77C\uC744 \uC0DD\uC131\uD558\uB294 \uC911...");
+  const webPort = skipInput ? "5173" : await p5.text({
     message: "Enter web port",
     placeholder: "5173",
     defaultValue: "5173"
   });
-  if (p2.isCancel(webPort)) {
-    p2.cancel("\uCD08\uAE30\uD654\uAC00 \uCDE8\uC18C\uB418\uC5C8\uC2B5\uB2C8\uB2E4");
+  if (p5.isCancel(webPort)) {
+    p5.cancel("\uCD08\uAE30\uD654\uAC00 \uCDE8\uC18C\uB418\uC5C8\uC2B5\uB2C8\uB2E4");
     return;
   }
   const config = transformTemplate(WEB_FRAMEWORK_CONFIG_TEMPLATE, {
     appName,
     webPort,
     webDevCommand: scriptInputs.dev === "granite dev" ? "" : scriptInputs.dev,
-    webBuildCommand: scriptInputs.build === "granite build" ? "" : scriptInputs.build
+    webBuildCommand: scriptInputs.build === "ait build" ? "" : scriptInputs.build
   });
-  await fs4.promises.writeFile(path3.join(cwd, "granite.config.ts"), config, {
+  await fs9.promises.writeFile(path10.join(cwd, "granite.config.ts"), config, {
     encoding: "utf-8"
   });
 }
 async function templateReactNative({ appName, cwd }) {
-  p2.log.step("granite.config.ts \uD30C\uC77C\uC744 \uC0DD\uC131\uD558\uB294 \uC911...");
+  const packageJsonPath = path10.join(cwd, "package.json");
+  const packageJsonRaw = await fs9.promises.readFile(packageJsonPath, {
+    encoding: "utf-8"
+  });
+  const packageJson = JSON.parse(packageJsonRaw);
+  packageJson.scripts ||= {};
+  packageJson.scripts.dev = "granite dev";
+  packageJson.scripts.build = "ait build";
+  packageJson.scripts.deploy = "ait deploy";
+  await fs9.promises.writeFile(packageJsonPath, JSON.stringify(packageJson, null, 2), {
+    encoding: "utf-8"
+  });
+  p5.log.step("granite.config.ts \uD30C\uC77C\uC744 \uC0DD\uC131\uD558\uB294 \uC911...");
   const config = transformTemplate(REACT_NATIVE_FRAMEWORK_CONFIG_TEMPLATE, {
     appName
   });
-  await fs4.promises.writeFile(path3.join(cwd, "granite.config.ts"), config, {
+  await fs9.promises.writeFile(path10.join(cwd, "granite.config.ts"), config, {
     encoding: "utf-8"
   });
-  p2.log.step("src/_app.tsx \uD30C\uC77C\uC744 \uC0DD\uC131\uD558\uB294 \uC911...");
-  await fs4.promises.writeFile(path3.join(cwd, "src", "_app.tsx"), APP_TEMPLATE, {
+  p5.log.step("src/_app.tsx \uD30C\uC77C\uC744 \uC0DD\uC131\uD558\uB294 \uC911...");
+  await fs9.promises.writeFile(path10.join(cwd, "src", "_app.tsx"), APP_TEMPLATE, {
     encoding: "utf-8"
   });
 }
-var InitCommand = class extends Command2 {
+var InitCommand = class extends Command3 {
   static paths = [[`init`]];
   template = Option2.String("--template", { required: false });
   appName = Option2.String("--app-name", { required: false });
@@ -1346,7 +2003,7 @@ var InitCommand = class extends Command2 {
   async execute() {
     const template = await ensureSelect({
       value: this.template,
-      prompt: async () => p2.select({
+      prompt: async () => p5.select({
         message: "\uD504\uB85C\uC81D\uD2B8\uB97C \uCD08\uAE30\uD654\uD560 \uD15C\uD50C\uB9BF\uC744 \uC120\uD0DD\uD574\uC8FC\uC138\uC694.",
         options: [
           {
@@ -1362,14 +2019,14 @@ var InitCommand = class extends Command2 {
         ]
       })
     });
-    if (p2.isCancel(template)) {
+    if (p5.isCancel(template)) {
       process.exit(0);
     }
-    const cwd = getPackageRoot2();
-    p2.intro("\u{1F680} \uC571 \uCD08\uAE30\uD654\uB97C \uC2DC\uC791\uD569\uB2C8\uB2E4");
+    const cwd = getPackageRoot3();
+    p5.intro("\u{1F680} \uC571 \uCD08\uAE30\uD654\uB97C \uC2DC\uC791\uD569\uB2C8\uB2E4");
     const appName = await ensureSelect({
       value: this.appName,
-      prompt: async () => p2.text({
+      prompt: async () => p5.text({
         message: "Enter app name",
         validate: (value) => {
           if (!value) {
@@ -1383,11 +2040,11 @@ var InitCommand = class extends Command2 {
         }
       })
     });
-    if (p2.isCancel(appName)) {
-      p2.cancel("\uCD08\uAE30\uD654\uAC00 \uCDE8\uC18C\uB418\uC5C8\uC2B5\uB2C8\uB2E4");
+    if (p5.isCancel(appName)) {
+      p5.cancel("\uCD08\uAE30\uD654\uAC00 \uCDE8\uC18C\uB418\uC5C8\uC2B5\uB2C8\uB2E4");
       return;
     }
-    p2.log.step(`\uC571 \uC774\uB984\uC774 '${appName}'\uC73C\uB85C \uC124\uC815\uB418\uC5C8\uC2B5\uB2C8\uB2E4`);
+    p5.log.step(`\uC571 \uC774\uB984\uC774 '${appName}'\uC73C\uB85C \uC124\uC815\uB418\uC5C8\uC2B5\uB2C8\uB2E4`);
     switch (template) {
       case "web-framework": {
         await templateWebFramework({
@@ -1405,7 +2062,7 @@ var InitCommand = class extends Command2 {
         break;
       }
     }
-    p2.outro("\u2728 \uCD08\uAE30\uD654\uAC00 \uC644\uB8CC\uB418\uC5C8\uC2B5\uB2C8\uB2E4!");
+    p5.outro("\u2728 \uCD08\uAE30\uD654\uAC00 \uC644\uB8CC\uB418\uC5C8\uC2B5\uB2C8\uB2E4!");
   }
 };
 
@@ -1414,7 +2071,7 @@ init_esm_shims();
 
 // src/MigrateCommand/MigrateCommand.ts
 init_esm_shims();
-import { Command as Command3, Option as Option3 } from "clipanion";
+import { Command as Command4, Option as Option3 } from "clipanion";
 
 // src/MigrateCommand/logger/index.ts
 init_esm_shims();
@@ -1452,24 +2109,24 @@ init_esm_shims();
 
 // src/MigrateCommand/fs/fileProcessor.ts
 init_esm_shims();
-import { promises as fs5 } from "fs";
+import { promises as fs10 } from "fs";
 async function readFile(filePath) {
   try {
-    return await fs5.readFile(filePath, "utf-8");
+    return await fs10.readFile(filePath, "utf-8");
   } catch {
     throw new Error(`Failed to read file: ${filePath}`);
   }
 }
 async function writeFile(filePath, content) {
   try {
-    await fs5.writeFile(filePath, content, "utf-8");
+    await fs10.writeFile(filePath, content, "utf-8");
   } catch {
     throw new Error(`Failed to write file: ${filePath}`);
   }
 }
 async function fileExists(filePath) {
   try {
-    await fs5.access(filePath);
+    await fs10.access(filePath);
     return true;
   } catch {
     return false;
@@ -1477,7 +2134,7 @@ async function fileExists(filePath) {
 }
 async function renameFile(oldPath, newPath) {
   try {
-    await fs5.rename(oldPath, newPath);
+    await fs10.rename(oldPath, newPath);
   } catch {
     throw new Error(`Failed to rename file: ${oldPath} -> ${newPath}`);
   }
@@ -1485,27 +2142,27 @@ async function renameFile(oldPath, newPath) {
 
 // src/MigrateCommand/presets/granite/configProcessor.ts
 var configTransformer = (root, { j }) => {
-  root.find(j.ImportDeclaration).forEach((path6) => {
-    const source = path6.value.source;
+  root.find(j.ImportDeclaration).forEach((path13) => {
+    const source = path13.value.source;
     if (j.StringLiteral.check(source) && source.value === "react-native-bedrock/config") {
-      const defineConfigName = path6.value.specifiers?.find(
+      const defineConfigName = path13.value.specifiers?.find(
         (specifier) => j.ImportSpecifier.check(specifier) && specifier.imported.name === "defineConfig"
       )?.local?.name;
       if (!defineConfigName) {
         return;
       }
-      root.find(j.CallExpression).forEach((path7) => {
-        const callee = path7.value.callee;
-        if (j.Identifier.check(callee) && callee.name === defineConfigName && path7.value.arguments.length > 0 && j.ObjectExpression.check(path7.value.arguments[0])) {
-          const obj = path7.value.arguments[0];
+      root.find(j.CallExpression).forEach((path14) => {
+        const callee = path14.value.callee;
+        if (j.Identifier.check(callee) && callee.name === defineConfigName && path14.value.arguments.length > 0 && j.ObjectExpression.check(path14.value.arguments[0])) {
+          const obj = path14.value.arguments[0];
           const hasScheme = obj.properties.some(
             (prop) => j.ObjectProperty.check(prop) && j.Identifier.check(prop.key) && prop.key.name === "scheme"
           );
           if (!hasScheme) {
             obj.properties.unshift(j.objectProperty(j.identifier("scheme"), j.stringLiteral("intoss")));
           }
-          const routerImport = root.find(j.ImportDeclaration).filter((path8) => {
-            const source2 = path8.value.source;
+          const routerImport = root.find(j.ImportDeclaration).filter((path15) => {
+            const source2 = path15.value.source;
             return j.StringLiteral.check(source2) && source2.value === "@granite-js/plugin-router";
           });
           if (routerImport.length === 0) {
@@ -1654,12 +2311,12 @@ var identifierReplacementsTransformer = (root, { j }) => {
       }
     });
   });
-  root.find(j.Identifier).forEach((path6) => {
-    const name = path6.value.name;
+  root.find(j.Identifier).forEach((path13) => {
+    const name = path13.value.name;
     if (importedVariables.has(name)) {
-      const newName = toGraniteName(path6.value.name);
+      const newName = toGraniteName(path13.value.name);
       if (newName) {
-        path6.value.name = newName;
+        path13.value.name = newName;
       }
     }
   });
@@ -1668,11 +2325,11 @@ var identifierReplacementsTransformer = (root, { j }) => {
 
 // src/MigrateCommand/presets/granite/isBedrockProject.ts
 init_esm_shims();
-import * as fs6 from "fs";
+import * as fs11 from "fs";
 var BASE_NAME = "bedrock.config";
 var EXTENSIONS = ["ts", "mts", "js", "cjs"];
 async function isBedrockProject(cwd) {
-  const files = fs6.readdirSync(cwd);
+  const files = fs11.readdirSync(cwd);
   return files.some(isBedrockConfigFile);
 }
 function isBedrockConfigFile(file) {
@@ -1712,8 +2369,8 @@ var packageImportsTransformer = (root, { j }, { fileName = "<unknown>" }) => {
     }
     return value;
   }
-  root.find(j.ImportDeclaration).forEach((path6) => {
-    const source = path6.value.source;
+  root.find(j.ImportDeclaration).forEach((path13) => {
+    const source = path13.value.source;
     if (j.StringLiteral.check(source)) {
       const transformed = transformPackageName(source.value);
       if (transformed !== source.value) {
@@ -1723,8 +2380,8 @@ var packageImportsTransformer = (root, { j }, { fileName = "<unknown>" }) => {
   });
   root.find(j.CallExpression, {
     callee: { name: "require" }
-  }).forEach((path6) => {
-    const args = path6.value.arguments;
+  }).forEach((path13) => {
+    const args = path13.value.arguments;
     if (args.length > 0 && j.StringLiteral.check(args[0])) {
       const transformed = transformPackageName(args[0].value);
       if (transformed !== args[0].value) {
@@ -1732,8 +2389,8 @@ var packageImportsTransformer = (root, { j }, { fileName = "<unknown>" }) => {
       }
     }
   });
-  root.find(j.ImportExpression).forEach((path6) => {
-    const source = path6.value.source;
+  root.find(j.ImportExpression).forEach((path13) => {
+    const source = path13.value.source;
     if (j.StringLiteral.check(source)) {
       const transformed = transformPackageName(source.value);
       if (transformed !== source.value) {
@@ -1794,9 +2451,19 @@ var processPackageJson = async (cwd, config) => {
     if (packageJson.scripts) {
       const scripts = packageJson.scripts;
       for (const [key, value] of Object.entries(scripts)) {
-        if (typeof value === "string" && value.includes("bedrock")) {
-          scripts[key] = value.replace(/\bbedrock\b/g, "granite");
-          modified ||= true;
+        if (typeof value !== "string") {
+          continue;
+        }
+        let nextValue = value;
+        if (nextValue.includes("bedrock")) {
+          nextValue = nextValue.replace(/\bbedrock\b/g, "granite");
+        }
+        if (nextValue.includes("granite build")) {
+          nextValue = nextValue.replace(/granite build/g, "ait build");
+        }
+        if (nextValue !== value) {
+          scripts[key] = nextValue;
+          modified = true;
         }
       }
     }
@@ -1831,14 +2498,14 @@ var APPS_IN_TOSS_FRAMEWORK_EXPORTS = [
 ];
 var toAppsInTossFrameworkImport = (root, { j }, { fileName = "<unknown>" }) => {
   const appsInTossFrameworkMembers = [];
-  root.find(j.ImportDeclaration).forEach((path6) => {
-    const source = path6.node.source.value;
+  root.find(j.ImportDeclaration).forEach((path13) => {
+    const source = path13.node.source.value;
     if (typeof source !== "string") {
       return;
     }
     if (source === "@granite-js/react-native") {
-      if (Array.isArray(path6.node.specifiers)) {
-        path6.node.specifiers = path6.node.specifiers.filter((specifier) => {
+      if (Array.isArray(path13.node.specifiers)) {
+        path13.node.specifiers = path13.node.specifiers.filter((specifier) => {
           if (shouldImportFromAppsInTossFramework(fileName, specifier)) {
             appsInTossFrameworkMembers.push(specifier);
             return false;
@@ -1846,8 +2513,8 @@ var toAppsInTossFrameworkImport = (root, { j }, { fileName = "<unknown>" }) => {
           return true;
         });
       }
-      if (path6.node.specifiers?.length === 0) {
-        j(path6).remove();
+      if (path13.node.specifiers?.length === 0) {
+        j(path13).remove();
       }
     }
   });
@@ -1869,33 +2536,6 @@ function shouldImportFromAppsInTossFramework(fileName, specifier) {
   }
 }
 
-// src/MigrateCommand/codemod/index.ts
-init_esm_shims();
-
-// src/MigrateCommand/codemod/transform.ts
-init_esm_shims();
-import jscodeshift from "jscodeshift";
-function transform(source, { transformers: transformers2, options = {} }) {
-  const j = jscodeshift.withParser("tsx");
-  const report = [];
-  const stats = /* @__PURE__ */ new Map();
-  const context = {
-    j,
-    jscodeshift: j,
-    stats: (name, quantity = 1) => {
-      if (quantity === 0) {
-        return;
-      }
-      stats.set(name, (stats.get(name) ?? 0) + quantity);
-    },
-    report: (message) => {
-      report.push(message);
-    }
-  };
-  const root = transformers2.reduce((root2, transformer) => transformer(root2, context, options), j(source));
-  return root.toSource();
-}
-
 // src/MigrateCommand/fs/fileScanner.ts
 init_esm_shims();
 import glob from "fast-glob";
@@ -1960,26 +2600,239 @@ var migrateGranite = async (cwd, config) => {
   `);
 };
 
+// src/MigrateCommand/presets/react-native-0-84-0/index.ts
+init_esm_shims();
+
+// src/MigrateCommand/presets/react-native-0-84-0/migrateReactNative0840.ts
+init_esm_shims();
+import dedent2 from "dedent";
+var TARGET_DEPENDENCY_VERSIONS = {
+  react: "19.2.3",
+  "react-dom": "19.2.3",
+  "react-native": "0.84.0",
+  "@types/react": "19.2.3",
+  "@types/react-dom": "19.2.3",
+  "react-test-renderer": "19.2.3",
+  "babel-preset-granite": "1.0.3",
+  "@babel/plugin-transform-flow-strip-types": "7.27.1",
+  "@granite-js/react-native": "1.0.4",
+  "@granite-js/native": "1.0.4",
+  "@granite-js/plugin-core": "1.0.4",
+  "@granite-js/plugin-env": "1.0.4",
+  "@granite-js/plugin-hermes": "1.0.4",
+  "@granite-js/plugin-router": "1.0.4",
+  "@granite-js/plugin-micro-frontend": "1.0.4",
+  "@granite-js/plugin-sentry": "1.0.4",
+  "@toss/tds-react-native": "2.0.2",
+  "brick-module": "0.5.0"
+};
+var BABEL_CONFIG_TEMPLATE = `module.exports = {
+  presets: ['babel-preset-granite'],
+};
+`;
+var REQUIRED_DEPENDENCIES_BY_FIELD = {
+  dependencies: {
+    "brick-module": TARGET_DEPENDENCY_VERSIONS["brick-module"]
+  },
+  devDependencies: {
+    "babel-preset-granite": TARGET_DEPENDENCY_VERSIONS["babel-preset-granite"]
+  }
+};
+var DEPENDENCY_FIELDS = ["dependencies", "devDependencies", "peerDependencies"];
+function processDependencyMap(deps, frameworkVersion) {
+  let modified = false;
+  for (const [name, version] of Object.entries(deps)) {
+    if (name.startsWith("@apps-in-toss/")) {
+      if (name === "@apps-in-toss/framework" || frameworkVersion == null) {
+        continue;
+      }
+      if (version !== frameworkVersion) {
+        deps[name] = frameworkVersion;
+        modified = true;
+      }
+      continue;
+    }
+    const targetVersion = TARGET_DEPENDENCY_VERSIONS[name];
+    if (targetVersion == null || version === targetVersion) {
+      continue;
+    }
+    if (version !== targetVersion) {
+      deps[name] = targetVersion;
+      modified = true;
+    }
+  }
+  return modified;
+}
+function findDependencyVersion(packageJson, dependencyName) {
+  for (const field of DEPENDENCY_FIELDS) {
+    const deps = packageJson[field];
+    if (deps?.[dependencyName] != null) {
+      return deps[dependencyName];
+    }
+  }
+  return void 0;
+}
+function hasReactNativeDependency(packageJson) {
+  return findDependencyVersion(packageJson, "react-native") != null;
+}
+function processScriptMap(scripts) {
+  let modified = false;
+  for (const [scriptName, scriptValue] of Object.entries(scripts)) {
+    if (!scriptValue.includes("granite build")) {
+      continue;
+    }
+    const nextScriptValue = scriptValue.replace(/granite build/g, "ait build");
+    if (nextScriptValue !== scriptValue) {
+      scripts[scriptName] = nextScriptValue;
+      modified = true;
+    }
+  }
+  return modified;
+}
+function ensureRequiredDependencies(packageJson) {
+  let modified = false;
+  for (const field of DEPENDENCY_FIELDS) {
+    const requiredDependencies = REQUIRED_DEPENDENCIES_BY_FIELD[field];
+    if (requiredDependencies == null) {
+      continue;
+    }
+    packageJson[field] ??= {};
+    const deps = packageJson[field];
+    if (deps == null) {
+      continue;
+    }
+    for (const [dependencyName, requiredVersion] of Object.entries(requiredDependencies)) {
+      if (deps[dependencyName] === requiredVersion) {
+        continue;
+      }
+      deps[dependencyName] = requiredVersion;
+      modified = true;
+    }
+  }
+  return modified;
+}
+async function processPackageJson2(cwd, config) {
+  logger.log("Processing package.json...");
+  const packageJsonPath = `${cwd}/package.json`;
+  if (!await fileExists(packageJsonPath)) {
+    logger.log("No package.json found");
+    return false;
+  }
+  try {
+    const content = await readFile(packageJsonPath);
+    const packageJson = JSON.parse(content);
+    if (!hasReactNativeDependency(packageJson)) {
+      logger.log("Skipping migration: react-native dependency not found in package.json");
+      return false;
+    }
+    const appsInTossFrameworkVersion = findDependencyVersion(packageJson, "@apps-in-toss/framework");
+    let modified = false;
+    for (const field of DEPENDENCY_FIELDS) {
+      if (packageJson[field] == null) {
+        continue;
+      }
+      modified = processDependencyMap(packageJson[field], appsInTossFrameworkVersion) || modified;
+    }
+    modified = ensureRequiredDependencies(packageJson) || modified;
+    if (packageJson.scripts != null) {
+      modified = processScriptMap(packageJson.scripts) || modified;
+    }
+    if (!modified) {
+      logger.log("No changes needed in package.json");
+      return true;
+    }
+    if (config.dryRun === true) {
+      logger.log("Skipping package.json write in dry run mode");
+      return true;
+    }
+    await writeFile(packageJsonPath, JSON.stringify(packageJson, null, 2) + "\n");
+    logger.success("Updated package.json");
+    return true;
+  } catch (error) {
+    logger.error(`Failed to process package.json: ${error}`);
+    return false;
+  }
+}
+function isTargetBabelConfig(content) {
+  return content.trim() === BABEL_CONFIG_TEMPLATE.trim();
+}
+async function processBabelConfig(cwd, config) {
+  logger.log("Processing babel.config.js...");
+  const babelConfigPath = `${cwd}/babel.config.js`;
+  if (!await fileExists(babelConfigPath)) {
+    logger.log("No babel.config.js found");
+    return;
+  }
+  try {
+    const content = await readFile(babelConfigPath);
+    if (isTargetBabelConfig(content)) {
+      logger.log("No changes needed in babel.config.js");
+      return;
+    }
+    if (config.dryRun === true) {
+      logger.log("Skipping babel.config.js write in dry run mode");
+      return;
+    }
+    await writeFile(babelConfigPath, BABEL_CONFIG_TEMPLATE);
+    logger.success("Updated babel.config.js");
+  } catch (error) {
+    logger.error(`Failed to process babel.config.js: ${error}`);
+  }
+}
+var migrateReactNative0840 = async (cwd, config) => {
+  const isReactNativeProject = await processPackageJson2(cwd, config);
+  if (!isReactNativeProject) {
+    logger.log("Skipping remaining migration steps");
+    return;
+  }
+  await processBabelConfig(cwd, config);
+  logger.log(dedent2`
+  Please check the following steps:
+
+  - Install dependencies
+  - Run type checks
+  - Run lint checks
+  - Run tests
+  - Review migration warnings manually (if any)\n
+  `);
+};
+
 // src/MigrateCommand/presets/index.ts
 var MIGRATE_PRESETS = {
-  granite: migrateGranite
+  granite: migrateGranite,
+  "react-native-0-84-0": migrateReactNative0840
 };
 
 // src/MigrateCommand/MigrateCommand.ts
-var MigrateCommand = class extends Command3 {
+function getAvailablePresetTargets() {
+  return Object.keys(MIGRATE_PRESETS).sort();
+}
+function logAvailablePresets(level = "log") {
+  const output = level === "error" ? logger.error.bind(logger) : logger.log.bind(logger);
+  output("Available migration presets:");
+  for (const target of getAvailablePresetTargets()) {
+    output(`- ${target}`);
+  }
+}
+var MigrateCommand = class extends Command4 {
   static paths = [[`migrate`]];
-  static usage = Command3.Usage({
+  static usage = Command4.Usage({
     category: "Migration",
     description: "Run migration",
     examples: [
       ["Run migration", "ait migrate <target>"],
-      ["Check migration availability", "ait migrate <target> --dryRun"]
+      ["Check migration availability", "ait migrate"],
+      ["Dry run migration", "ait migrate <target> --dry-run"]
     ]
   });
-  target = Option3.String({ required: true });
+  target = Option3.String({ required: false });
   dryRun = Option3.Boolean("--dry-run", { required: false });
   async execute() {
     try {
+      if (this.target == null) {
+        logAvailablePresets();
+        return 0;
+      }
       const cwd = process.cwd();
       const config = {
         dryRun: this.dryRun
@@ -1988,7 +2841,9 @@ var MigrateCommand = class extends Command3 {
       logger.log(`Working directory: ${cwd}`);
       const migrate = MIGRATE_PRESETS[this.target];
       if (migrate == null) {
-        throw new Error(`Unknown target: ${this.target}`);
+        logger.error(`Unknown target: ${this.target}`);
+        logAvailablePresets("error");
+        return 1;
       }
       await migrate(cwd, config);
       logger.success("Migration completed successfully!");
@@ -2003,12 +2858,12 @@ var MigrateCommand = class extends Command3 {
 // src/TokenCommand.ts
 init_esm_shims();
 var import_debug3 = __toESM(require_src(), 1);
-import * as p3 from "@clack/prompts";
-import { Command as Command4, Option as Option4 } from "clipanion";
+import * as p6 from "@clack/prompts";
+import { Command as Command5, Option as Option4 } from "clipanion";
 var debug3 = (0, import_debug3.default)("cli:token");
-var TokenCommand = class extends Command4 {
+var TokenCommand = class extends Command5 {
   static paths = [["token"]];
-  static usage = Command4.Usage({
+  static usage = Command5.Usage({
     description: "\uD1A0\uD070 \uAD00\uB828 \uD558\uC704 \uBA85\uB839\uC744 \uAD00\uB9AC\uD569\uB2C8\uB2E4.",
     examples: [
       ["\uD1A0\uD070 \uCD94\uAC00", "ait token add <profile?>"],
@@ -2019,9 +2874,9 @@ var TokenCommand = class extends Command4 {
     debug3("execute");
   }
 };
-var TokenAddCommand = class extends Command4 {
+var TokenAddCommand = class extends Command5 {
   static paths = [["token", "add"]];
-  static usage = Command4.Usage({
+  static usage = Command5.Usage({
     description: "\uC2DC\uD06C\uB9BF \uD1A0\uD070\uC744 \uCD94\uAC00\uD569\uB2C8\uB2E4.",
     examples: [
       ["\uAE30\uBCF8 \uBCC4\uCE6D\uC73C\uB85C \uD1A0\uD070 \uCD94\uAC00", "ait token add"],
@@ -2032,7 +2887,7 @@ var TokenAddCommand = class extends Command4 {
   apiKey = Option4.String("--api-key", { required: false });
   async execute() {
     const profile = this.profile || "default";
-    const secret = this.apiKey ? this.apiKey : await p3.password({
+    const secret = this.apiKey ? this.apiKey : await p6.password({
       message: "Enter secret token:",
       validate: (value) => {
         if (value.length === 0) {
@@ -2041,7 +2896,7 @@ var TokenAddCommand = class extends Command4 {
         return;
       }
     });
-    if (p3.isCancel(secret)) {
+    if (p6.isCancel(secret)) {
       return;
     }
     TokenStorage.set(profile, secret);
@@ -2050,9 +2905,9 @@ var TokenAddCommand = class extends Command4 {
 `);
   }
 };
-var TokenRemoveCommand = class extends Command4 {
+var TokenRemoveCommand = class extends Command5 {
   static paths = [["token", "remove"]];
-  static usage = Command4.Usage({
+  static usage = Command5.Usage({
     description: "\uC2DC\uD06C\uB9BF \uD1A0\uD070\uC744 \uC0AD\uC81C\uD569\uB2C8\uB2E4.",
     examples: [
       ["\uAE30\uBCF8 \uC6CC\uD06C\uC2A4\uD398\uC774\uC2A4\uC758 \uD1A0\uD070 \uC0AD\uC81C", "ait token remove"],
@@ -2079,16 +2934,16 @@ init_esm_shims();
 
 // src/integrations/UploadSentrySourcemap/UploadSentrySourcemap.ts
 init_esm_shims();
-import * as fs10 from "fs/promises";
-import * as p4 from "@clack/prompts";
-import { Command as Command5, Option as Option5 } from "clipanion";
+import * as fs15 from "fs/promises";
+import * as p7 from "@clack/prompts";
+import { Command as Command6, Option as Option5 } from "clipanion";
 
 // src/integrations/UploadSentrySourcemap/downloadArtifacts.ts
 init_esm_shims();
 var import_debug4 = __toESM(require_src(), 1);
-import * as fs7 from "fs";
+import * as fs12 from "fs";
 import * as os2 from "os";
-import * as path4 from "path";
+import * as path11 from "path";
 import { pipeline } from "stream";
 import { promisify } from "util";
 var debug4 = (0, import_debug4.default)("integrations:sentry");
@@ -2116,36 +2971,36 @@ async function downloadArtifacts(options) {
   }
   const tmpDir = await createTempDirectory();
   const tmpFile = `${deploymentId}.zip`;
-  const tmpFilePath = path4.join(tmpDir.path, tmpFile);
-  const fileStream = fs7.createWriteStream(tmpFilePath);
+  const tmpFilePath = path11.join(tmpDir.path, tmpFile);
+  const fileStream = fs12.createWriteStream(tmpFilePath);
   await streamPipeline(response.body, fileStream);
   debug4("Artifacts downloaded", { tmpFilePath });
   return tmpFilePath;
 }
 function createTempDirectory() {
-  const tempDir = path4.join(os2.tmpdir(), "apps-in-toss", "sentry-integration");
-  fs7.mkdirSync(tempDir, { recursive: true });
+  const tempDir = path11.join(os2.tmpdir(), "apps-in-toss", "sentry-integration");
+  fs12.mkdirSync(tempDir, { recursive: true });
   debug4("Temp directory created", { tempDir });
   return {
     path: tempDir,
     cleanup: () => {
-      fs7.rmSync(tempDir, { recursive: true, force: true });
+      fs12.rmSync(tempDir, { recursive: true, force: true });
     }
   };
 }
 
 // src/integrations/UploadSentrySourcemap/extractSentryDebugId.ts
 init_esm_shims();
-import fs8 from "fs/promises";
+import fs13 from "fs/promises";
 async function extractSentryDebugId(bundlePath) {
-  const bundleContent = await fs8.readFile(bundlePath, "utf-8");
+  const bundleContent = await fs13.readFile(bundlePath, "utf-8");
   return bundleContent.match(/SENTRY_DEBUG_ID=([\w-]+)/)?.[1];
 }
 
 // src/integrations/UploadSentrySourcemap/extractSources.ts
 init_esm_shims();
-import * as fs9 from "fs";
-import * as path5 from "path";
+import * as fs14 from "fs";
+import * as path12 from "path";
 import { pipeline as pipeline2 } from "stream";
 import { promisify as promisify2 } from "util";
 import * as zlib from "zlib";
@@ -2166,12 +3021,12 @@ async function extractSources(zipPath) {
       hermesSourceMap: ""
     }
   };
-  await fs9.createReadStream(zipPath).pipe(unzipper.Parse()).on("entry", async (entry) => {
+  await fs14.createReadStream(zipPath).pipe(unzipper.Parse()).on("entry", async (entry) => {
     const isRoot = !entry.path.includes("/");
-    const fileName = path5.basename(entry.path);
-    const outputPath = path5.join(path5.dirname(zipPath), fileName);
+    const fileName = path12.basename(entry.path);
+    const outputPath = path12.join(path12.dirname(zipPath), fileName);
     if (isRoot) {
-      entry.pipe(fs9.createWriteStream(outputPath));
+      entry.pipe(fs14.createWriteStream(outputPath));
       const platform = fileName.includes("android") ? "android" : "ios";
       if (fileName.endsWith(".js")) {
         sources[platform].packagerBundle = outputPath;
@@ -2199,7 +3054,7 @@ async function extractSources(zipPath) {
 }
 async function decompressGzip(gzFile) {
   const outfile = gzFile.replace(/\.gz$/g, "");
-  await pipe(fs9.createReadStream(gzFile), zlib.createGunzip(), fs9.createWriteStream(outfile));
+  await pipe(fs14.createReadStream(gzFile), zlib.createGunzip(), fs14.createWriteStream(outfile));
   return outfile;
 }
 
@@ -2230,7 +3085,7 @@ function uploadSourcemap(bundlePath, sourcemapPath, options) {
 }
 
 // src/integrations/UploadSentrySourcemap/UploadSentrySourcemap.ts
-var UploadSentrySourcemap = class extends Command5 {
+var UploadSentrySourcemap = class extends Command6 {
   static paths = [["sentry", "upload-sourcemap"]];
   apiKey = Option5.String("--api-key", {
     required: false,
@@ -2270,7 +3125,7 @@ var UploadSentrySourcemap = class extends Command5 {
     try {
       const zipPath = await downloadArtifacts({ apiKey, appName, deploymentId, baseUrl });
       const sources = await extractSources(zipPath);
-      await p4.tasks([
+      await p7.tasks([
         {
           title: "Android \uC18C\uC2A4\uB9F5 \uC5C5\uB85C\uB4DC \uC911...",
           task: async () => {
@@ -2296,10 +3151,10 @@ var UploadSentrySourcemap = class extends Command5 {
           }
         }
       ]);
-      p4.outro("Sentry \uC18C\uC2A4\uB9F5 \uC5C5\uB85C\uB4DC \uC644\uB8CC");
+      p7.outro("Sentry \uC18C\uC2A4\uB9F5 \uC5C5\uB85C\uB4DC \uC644\uB8CC");
     } catch (error) {
       if (error instanceof Error) {
-        p4.log.error(error.message);
+        p7.log.error(error.message);
       } else {
         console.error(error);
       }
@@ -2312,14 +3167,14 @@ var UploadSentrySourcemap = class extends Command5 {
       throw new Error("Sentry Debug ID\uB97C \uCC3E\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4");
     }
     const mergedSourceMap = await mergeSourceMaps(
-      await fs10.readFile(sources.packagerSourceMap, "utf-8"),
-      await fs10.readFile(sources.hermesSourceMap, "utf-8")
+      await fs15.readFile(sources.packagerSourceMap, "utf-8"),
+      await fs15.readFile(sources.hermesSourceMap, "utf-8")
     );
     const injectedSourceMap = injectSentryDebugId(mergedSourceMap, debugId);
-    await fs10.writeFile(sources.hermesSourceMap, JSON.stringify(injectedSourceMap, null, 2), "utf-8");
+    await fs15.writeFile(sources.hermesSourceMap, JSON.stringify(injectedSourceMap, null, 2), "utf-8");
   }
   async promptRequiredValue(type, message, validateMessage) {
-    const result = await p4[type]({
+    const result = await p7[type]({
       message,
       validate: (value) => {
         if (value.length === 0) {
@@ -2328,7 +3183,7 @@ var UploadSentrySourcemap = class extends Command5 {
         return;
       }
     });
-    if (p4.isCancel(result)) {
+    if (p7.isCancel(result)) {
       throw new Error("\uC791\uC5C5\uC774 \uCDE8\uC18C\uB418\uC5C8\uC5B4\uC694.");
     }
     return result;
@@ -2336,11 +3191,13 @@ var UploadSentrySourcemap = class extends Command5 {
 };
 
 // src/index.ts
+import { babelBuild as babelBuild2, babelJsonReplacementPlugin, getPackageManager as getPackageManager3, loadConfig as loadConfig2 } from "@apps-in-toss/web-config";
 function initialize() {
   const cli = new Cli({
     binaryLabel: "ait",
     binaryName: "ait"
   });
+  cli.register(BuildCommand);
   cli.register(DeployCommand);
   cli.register(InitCommand);
   cli.register(MigrateCommand);
@@ -2352,5 +3209,9 @@ function initialize() {
   cli.runExit(process.argv.slice(2));
 }
 export {
-  initialize
+  babelBuild2 as babelBuild,
+  babelJsonReplacementPlugin,
+  getPackageManager3 as getPackageManager,
+  initialize,
+  loadConfig2 as loadConfig
 };