@granite-js/cli 0.0.0-dev-20250725013859

package/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2025 Viva Republica, Inc
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/README.md

@@ -0,0 +1,31 @@
+# @granite-js/cli
+
+The Granite CLI
+
+## Development
+
+```bash
+yarn build
+yarn run bin
+```
+
+## License
+
+This software is licensed under the [Apache 2 license](LICENSE), quoted below.
+
+```
+Copyright 2025 Viva Republica, Inc
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at:
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+
+```

package/dist/index.cjs

@@ -0,0 +1,415 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  defineConfig: () => defineConfig,
+  initialize: () => initialize,
+  loadConfig: () => loadConfig
+});
+module.exports = __toCommonJS(index_exports);
+var import_clipanion4 = require("clipanion");
+var import_cosmiconfig2 = require("cosmiconfig");
+
+// src/commands/BuildCommand/BuildCommand.ts
+var import_clipanion = require("clipanion");
+
+// src/commands/BuildCommand/build.ts
+var import_path = __toESM(require("path"), 1);
+var import_mpack = require("@granite-js/mpack");
+var import_plugins = require("@granite-js/mpack/plugins");
+var import_plugin_core = require("@granite-js/plugin-core");
+async function build(config, options) {
+  const pluginContext = (0, import_plugin_core.createContext)();
+  for (const preHandler of config.pluginHooks.build.preHandlers) {
+    await preHandler.call(pluginContext, {
+      cwd: config.cwd,
+      entryFile: config.entryFile,
+      appName: config.appName,
+      outdir: config.outdir
+    });
+  }
+  const buildResults = await Promise.all(
+    ["ios", "android"].map(
+      (platform) => (0, import_mpack.runBundle)({
+        rootDir: config.cwd,
+        dev: false,
+        metafile: true,
+        cache: options.cache,
+        plugins: [import_plugins.statusPlugin],
+        buildConfig: { platform, outfile: import_path.default.join(config.outdir, `bundle.${platform}.js`), ...config.build }
+      })
+    )
+  );
+  for (const postHandler of config.pluginHooks.build.postHandlers) {
+    await postHandler.call(pluginContext, {
+      cwd: config.cwd,
+      entryFile: config.entryFile,
+      appName: config.appName,
+      outdir: config.outdir,
+      buildResults
+    });
+  }
+}
+
+// src/config/loadConfig.ts
+var import_utils = require("@granite-js/utils");
+var import_cosmiconfig = require("cosmiconfig");
+var import_cosmiconfig_typescript_loader = require("cosmiconfig-typescript-loader");
+var MODULE_NAME = "granite";
+var loadConfig = async () => {
+  const explorer = (0, import_cosmiconfig.cosmiconfig)(MODULE_NAME, {
+    searchPlaces: [
+      `${MODULE_NAME}.config.ts`,
+      `${MODULE_NAME}.config.mts`,
+      `${MODULE_NAME}.config.js`,
+      `${MODULE_NAME}.config.cjs`
+    ],
+    loaders: {
+      ".ts": (0, import_cosmiconfig_typescript_loader.TypeScriptLoader)(),
+      ".mts": (0, import_cosmiconfig_typescript_loader.TypeScriptLoader)()
+    }
+  });
+  const result = await explorer.search((0, import_utils.getPackageRoot)());
+  const config = await result?.config;
+  return config;
+};
+
+// src/commands/BuildCommand/BuildCommand.ts
+var BuildCommand = class extends import_clipanion.Command {
+  static paths = [[`build`]];
+  static usage = import_clipanion.Command.Usage({
+    category: "Build",
+    description: "Build Granite App",
+    examples: [["Build Granite App", "granite build"]]
+  });
+  disableCache = import_clipanion.Option.Boolean("--disable-cache", {
+    description: "Disable cache"
+  });
+  async execute() {
+    try {
+      const { disableCache = false } = this;
+      const config = await loadConfig();
+      await build(config, {
+        cache: !disableCache
+      });
+      return 0;
+    } catch (error) {
+      console.error(error);
+      return 1;
+    }
+  }
+};
+
+// src/commands/HermesCommand/HermesCommand.ts
+var import_path3 = __toESM(require("path"), 1);
+var import_chalk = __toESM(require("chalk"), 1);
+var import_clipanion2 = require("clipanion");
+
+// src/utils/compileHbc.ts
+var import_assert = __toESM(require("assert"), 1);
+var import_os = __toESM(require("os"), 1);
+var import_path2 = __toESM(require("path"), 1);
+var import_es_toolkit = require("es-toolkit");
+var import_execa = __toESM(require("execa"), 1);
+var binary = {
+  Darwin: "react-native/sdks/hermesc/osx-bin/hermesc",
+  Linux: "react-native/sdks/hermesc/linux64-bin/hermesc",
+  Windows_NT: "react-native/sdks/hermesc/win64-bin/hermesc.exe"
+};
+async function compileHbc({ rootDir, filePath, sourcemap }) {
+  const binary2 = getHermesc(rootDir);
+  const outfile = import_path2.default.resolve(rootDir, filePath.replace(new RegExp(`${import_path2.default.extname(filePath)}$`), ".hbc"));
+  await (0, import_execa.default)(
+    binary2,
+    [
+      // Disable warnings
+      "-w",
+      // Expensive optimizations
+      "-O",
+      // Emit binary
+      "-emit-binary",
+      // Emit source map
+      sourcemap ? "-output-source-map" : null,
+      // Output path
+      "-out",
+      outfile,
+      filePath
+    ].filter(import_es_toolkit.isNotNil)
+  );
+  return { outfile, sourcemapOutfile: sourcemap ? `${outfile}.map` : null };
+}
+function getHermesc(rootDir) {
+  const os2 = getOs();
+  const binarySource = binary[os2];
+  (0, import_assert.default)(binarySource, `\uC9C0\uC6D0\uD558\uC9C0 \uC54A\uB294 OS \uC785\uB2C8\uB2E4: ${os2}`);
+  return resolveFromRoot(rootDir, binarySource);
+}
+function getOs() {
+  return import_os.default.type();
+}
+function resolveFromRoot(rootDir, request) {
+  return require.resolve(request, { paths: [rootDir] });
+}
+
+// src/commands/HermesCommand/HermesCommand.ts
+var HermesCommand = class extends import_clipanion2.Command {
+  static paths = [[`hermes`]];
+  static usage = import_clipanion2.Command.Usage({
+    category: "Hermes",
+    description: "\uC9C0\uC815\uD55C \uBC88\uB4E4\uC744 Hermes \uBC14\uC774\uD2B8 \uCF54\uB4DC\uB85C \uCEF4\uD30C\uC77C \uD569\uB2C8\uB2E4",
+    examples: [["\uCEF4\uD30C\uC77C\uD558\uAE30", "granite hermes --jsbundle dist/bundle.js"]]
+  });
+  jsBundleFile = import_clipanion2.Option.String("--jsbundle", {
+    required: true,
+    description: "Hermes \uBC14\uC774\uD2B8 \uCF54\uB4DC\uB85C \uCEF4\uD30C\uC77C \uD560 Javascript \uD30C\uC77C \uACBD\uB85C \uC785\uB2C8\uB2E4"
+  });
+  sourcemap = import_clipanion2.Option.Boolean("--sourcemap", true, {
+    description: "\uC18C\uC2A4\uB9F5 \uD30C\uC77C\uC744 \uC0DD\uC131\uD569\uB2C8\uB2E4"
+  });
+  async execute() {
+    try {
+      const rootDir = process.cwd();
+      const filePath = import_path3.default.resolve(rootDir, this.jsBundleFile);
+      const { outfile, sourcemapOutfile } = await compileHbc({ rootDir, filePath, sourcemap: this.sourcemap });
+      console.log(`\u2705 \uCEF4\uD30C\uC77C \uC644\uB8CC: ${import_chalk.default.gray(outfile)}`);
+      if (sourcemapOutfile) {
+        console.log(`\u2705 \uC18C\uC2A4\uB9F5 \uC0DD\uC131 \uC644\uB8CC: ${import_chalk.default.gray(sourcemapOutfile)}`);
+      }
+      return 0;
+    } catch (error) {
+      console.error(error.stack);
+      return 1;
+    }
+  }
+};
+
+// src/commands/DevCommand/DevCommand.ts
+var mpack = __toESM(require("@granite-js/mpack"), 1);
+var import_clipanion3 = require("clipanion");
+var import_debug = __toESM(require("debug"), 1);
+
+// src/commands/DevCommand/startDevServer.ts
+var import_mpack2 = require("@granite-js/mpack");
+var import_plugin_core2 = require("@granite-js/plugin-core");
+async function startDevServer(serverOptions, config) {
+  const pluginContext = (0, import_plugin_core2.createContext)();
+  const commonHandlerArgs = {
+    host: serverOptions.host,
+    port: serverOptions.port,
+    appName: config.appName,
+    outdir: config.outdir,
+    cwd: config.cwd,
+    entryFile: config.build.entry
+  };
+  for (const preHandler of config.pluginHooks.devServer.preHandlers) {
+    await preHandler.call(pluginContext, commonHandlerArgs);
+  }
+  await (0, import_mpack2.runServer)({
+    cwd: config.cwd,
+    host: serverOptions.host,
+    port: serverOptions.port,
+    middlewares: config.metro?.middlewares,
+    enableEmbeddedReactDevTools: !serverOptions.disableEmbeddedReactDevTools,
+    additionalConfig: config.metro,
+    onServerReady: async () => {
+      for (const postHandler of config.pluginHooks.devServer.postHandlers) {
+        await postHandler.call(pluginContext, commonHandlerArgs);
+      }
+    }
+  });
+}
+
+// src/commands/DevCommand/DevCommand.ts
+var debug = (0, import_debug.default)("cli");
+var DEFAULT_HOST = "0.0.0.0";
+var DEFAULT_LOCALHOST_PORT = 8081;
+var DevCommand = class extends import_clipanion3.Command {
+  static paths = [[`dev`]];
+  static usage = import_clipanion3.Command.Usage({
+    category: "Development",
+    description: "Run Granite development server",
+    examples: [["Run Granite development server", "granite dev"]]
+  });
+  host = import_clipanion3.Option.String("--host");
+  port = import_clipanion3.Option.String("--port");
+  disableEmbeddedReactDevTools = import_clipanion3.Option.Boolean("--disable-embedded-react-devtools", false);
+  // mpack dev-server
+  experimentalMode = import_clipanion3.Option.Boolean("--experimental-mode");
+  async execute() {
+    try {
+      process.env.MPACK_DEV_SERVER = "true";
+      const config = await loadConfig();
+      const serverOptions = {
+        host: this.host,
+        port: this.port ? parseInt(this.port, 10) : void 0
+      };
+      debug("StartCommand", {
+        ...serverOptions,
+        disableEmbeddedReactDevTools: this.disableEmbeddedReactDevTools,
+        experimentalMode: this.experimentalMode
+      });
+      if (this.experimentalMode) {
+        await mpack.EXPERIMENTAL__runServer({
+          buildConfig: config.build,
+          host: serverOptions.host,
+          port: serverOptions.port
+        });
+      } else {
+        await startDevServer(
+          {
+            host: serverOptions.host || DEFAULT_HOST,
+            port: serverOptions.port || DEFAULT_LOCALHOST_PORT,
+            disableEmbeddedReactDevTools: this.disableEmbeddedReactDevTools
+          },
+          config
+        );
+      }
+    } catch (error) {
+      console.log(`ERROR OCCURRED`);
+      console.log(error);
+      console.log(error.message);
+      console.error(error.stack);
+      process.exit(1);
+    }
+  }
+};
+
+// src/config/defineConfig.ts
+var import_path5 = __toESM(require("path"), 1);
+var import_plugin_core3 = require("@granite-js/plugin-core");
+var import_utils3 = require("@granite-js/utils");
+var import_es_toolkit2 = require("es-toolkit");
+var import_zod = require("zod");
+
+// src/config/graniteGlobals.ts
+var import_fs = __toESM(require("fs"), 1);
+var import_path4 = __toESM(require("path"), 1);
+var import_utils2 = require("@granite-js/utils");
+function prepareGraniteGlobalsScript(config) {
+  const filePath = writeGraniteGlobalsScript(config);
+  return {
+    esbuild: {
+      prelude: [filePath]
+    },
+    metro: {
+      prelude: [filePath]
+    }
+  };
+}
+function writeGraniteGlobalsScript(config) {
+  const script = getGraniteGlobalScript(config);
+  const filePath = import_path4.default.join((0, import_utils2.getLocalTempDirectoryPath)(config.rootDir), "granite-globals.js");
+  (0, import_utils2.prepareLocalDirectory)(config.rootDir);
+  import_fs.default.writeFileSync(filePath, script, "utf-8");
+  return filePath;
+}
+function getGraniteGlobalScript({ appName, scheme }) {
+  return [
+    "global.__granite = global.__granite || {};",
+    `global.__granite.app = { name: ${JSON.stringify(appName)}, scheme: ${JSON.stringify(scheme)} };`
+  ].join("\n");
+}
+
+// src/config/defineConfig.ts
+var graniteConfigSchema = import_zod.z.object({
+  cwd: import_zod.z.string().default(process.cwd()),
+  appName: import_zod.z.string(),
+  scheme: import_zod.z.string(),
+  outdir: import_zod.z.string().default("dist"),
+  entryFile: import_zod.z.string().default("./src/_app.tsx"),
+  build: import_zod.z.custom().optional(),
+  devServer: import_zod.z.custom().optional(),
+  metro: import_zod.z.custom().optional(),
+  plugins: import_zod.z.custom()
+});
+var defineConfig = async (config) => {
+  const parsed = graniteConfigSchema.parse(config);
+  const cwd = parsed.cwd ?? (0, import_utils3.getPackageRoot)();
+  const appName = parsed.appName;
+  const scheme = parsed.scheme;
+  const entryFile = import_path5.default.resolve(cwd, parsed.entryFile);
+  const outdir = import_path5.default.join(cwd, parsed.outdir);
+  const parsedBuildConfig = parsed.build;
+  const parsedDevServerConfig = parsed.devServer;
+  const parsedMetroConfig = parsed.metro;
+  const parsedConfig = {
+    ...parsedBuildConfig,
+    devServer: parsedDevServerConfig,
+    metro: parsedMetroConfig
+  };
+  const { configs, pluginHooks } = await (0, import_plugin_core3.resolvePlugins)(parsed.plugins);
+  const globalsScriptConfig = prepareGraniteGlobalsScript({ rootDir: cwd, appName, scheme });
+  const mergedConfig = (0, import_plugin_core3.mergeConfig)(parsedConfig, ...[globalsScriptConfig, ...configs].filter(import_es_toolkit2.isNotNil));
+  const { metro, devServer, ...buildConfig } = mergedConfig ?? {};
+  return {
+    cwd,
+    entryFile,
+    appName,
+    scheme,
+    outdir,
+    devServer,
+    pluginHooks,
+    build: {
+      ...buildConfig,
+      entry: entryFile
+    },
+    metro: {
+      ...metro,
+      babelConfig: mergedConfig?.babel,
+      transformSync: mergedConfig?.transformer?.transformSync
+    }
+  };
+};
+
+// src/index.ts
+var cli = new import_clipanion4.Cli({
+  binaryLabel: "granite",
+  binaryName: "granite",
+  enableCapture: true
+});
+async function initialize() {
+  const explorer = await (0, import_cosmiconfig2.cosmiconfig)("mpack");
+  const result = await explorer.search(process.cwd());
+  cli.register(BuildCommand);
+  cli.register(HermesCommand);
+  cli.register(DevCommand);
+  cli.register(import_clipanion4.Builtins.HelpCommand);
+  if (Array.isArray(result?.config?.commands)) {
+    (result?.config?.commands).forEach((command) => cli.register(command));
+  }
+  cli.runExit(process.argv.slice(2));
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  defineConfig,
+  initialize,
+  loadConfig
+});

package/dist/index.d.cts

@@ -0,0 +1,105 @@
+import { DevServerConfig, AdditionalMetroConfig, MetroDevServerConfig, BuildConfig as BuildConfig$1 } from '@granite-js/mpack';
+import { BuildConfig, PluginInput, GranitePluginDevPreHandler, GranitePluginDevPostHandler, GranitePluginBuildPreHandler, GranitePluginBuildPostHandler } from '@granite-js/plugin-core';
+import { z } from 'zod';
+
+declare const graniteConfigSchema: z.ZodObject<{
+    cwd: z.ZodDefault<z.ZodString>;
+    appName: z.ZodString;
+    scheme: z.ZodString;
+    outdir: z.ZodDefault<z.ZodString>;
+    entryFile: z.ZodDefault<z.ZodString>;
+    build: z.ZodOptional<z.ZodType<BuildConfig, z.ZodTypeDef, BuildConfig>>;
+    devServer: z.ZodOptional<z.ZodType<DevServerConfig, z.ZodTypeDef, DevServerConfig>>;
+    metro: z.ZodOptional<z.ZodType<AdditionalMetroConfig & MetroDevServerConfig, z.ZodTypeDef, AdditionalMetroConfig & MetroDevServerConfig>>;
+    plugins: z.ZodType<PluginInput, z.ZodTypeDef, PluginInput>;
+}, "strip", z.ZodTypeAny, {
+    appName: string;
+    scheme: string;
+    cwd: string;
+    outdir: string;
+    entryFile: string;
+    plugins: PluginInput;
+    build?: BuildConfig | undefined;
+    metro?: (AdditionalMetroConfig & MetroDevServerConfig) | undefined;
+    devServer?: DevServerConfig | undefined;
+}, {
+    appName: string;
+    scheme: string;
+    plugins: PluginInput;
+    build?: BuildConfig | undefined;
+    metro?: (AdditionalMetroConfig & MetroDevServerConfig) | undefined;
+    cwd?: string | undefined;
+    outdir?: string | undefined;
+    entryFile?: string | undefined;
+    devServer?: DevServerConfig | undefined;
+}>;
+type GraniteConfig = z.input<typeof graniteConfigSchema>;
+type CompleteGraniteConfig = Omit<z.output<typeof graniteConfigSchema>, 'build' | 'plugins'> & {
+    build: Omit<BuildConfig$1, 'platform' | 'outfile'>;
+    pluginHooks: GranitePluginHooks;
+};
+interface GranitePluginHooks {
+    devServer: {
+        preHandlers: GranitePluginDevPreHandler[];
+        postHandlers: GranitePluginDevPostHandler[];
+    };
+    build: {
+        preHandlers: GranitePluginBuildPreHandler[];
+        postHandlers: GranitePluginBuildPostHandler[];
+    };
+}
+/**
+ * @public
+ * @category Configuration
+ * @name defineConfig
+ * @description
+ * Configures your Granite application by defining key settings in `granite.config.ts`.
+ *
+ * The configuration lets you specify:
+ * - How users will access your app through a URL scheme (e.g. `granite://`)
+ * - Your app's unique name that appears in the URL (e.g. `granite://my-service`)
+ * - Build settings for bundlers like ESBuild and Metro
+ * - Code transformation settings through Babel
+ * - Additional functionality through Granite plugins
+ *
+ * @param config - Configuration options
+ * @param config.cwd - Working directory for build process (defaults to process.cwd())
+ * @param config.appName - Your app's unique identifier
+ * @param config.scheme - URL scheme for launching your app (e.g. 'granite')
+ * @param config.outdir - Where to output build files (defaults to 'dist')
+ * @param config.entryFile - Your app's entry point (defaults to './src/_app.tsx')
+ * @param config.build - Customize build settings
+ * @param config.metro - Configure Metro bundler settings
+ * @param config.devServer - Configure Mpack dev server settings
+ * @param config.plugins - Granite plugins to enhance functionality
+ * @returns The processed configuration
+ *
+ * @example
+ * Here's a basic configuration that:
+ * - Makes your app accessible via the `granite://` scheme
+ * - Names your service "my-app" so it's reachable at `granite://my-app`
+ * - Uses the Hermes plugin to optimize JavaScript bundles into bytecode
+ *
+ * ```ts
+ * import { defineConfig } from '@granite-js/react-native/config';
+ * import { hermes } from '@granite-js/plugin-hermes';
+ *
+ * export default defineConfig({
+ *   // The name of your microservice
+ *   appName: 'my-app',
+ *   // The URL scheme for deep linking
+ *   scheme: 'granite',
+ *   // Entry file path
+ *   entryFile: 'index.ts',
+ *   // Array of plugins to use
+ *   plugins: [hermes()],
+ * });
+ * ```
+ */
+declare const defineConfig: (config: GraniteConfig) => Promise<CompleteGraniteConfig>;
+
+declare const loadConfig: () => Promise<CompleteGraniteConfig>;
+
+declare function initialize(): Promise<void>;
+
+export { type CompleteGraniteConfig, type GraniteConfig, type GranitePluginHooks, defineConfig, initialize, loadConfig };

package/dist/index.d.ts

@@ -0,0 +1,105 @@
+import { DevServerConfig, AdditionalMetroConfig, MetroDevServerConfig, BuildConfig as BuildConfig$1 } from '@granite-js/mpack';
+import { BuildConfig, PluginInput, GranitePluginDevPreHandler, GranitePluginDevPostHandler, GranitePluginBuildPreHandler, GranitePluginBuildPostHandler } from '@granite-js/plugin-core';
+import { z } from 'zod';
+
+declare const graniteConfigSchema: z.ZodObject<{
+    cwd: z.ZodDefault<z.ZodString>;
+    appName: z.ZodString;
+    scheme: z.ZodString;
+    outdir: z.ZodDefault<z.ZodString>;
+    entryFile: z.ZodDefault<z.ZodString>;
+    build: z.ZodOptional<z.ZodType<BuildConfig, z.ZodTypeDef, BuildConfig>>;
+    devServer: z.ZodOptional<z.ZodType<DevServerConfig, z.ZodTypeDef, DevServerConfig>>;
+    metro: z.ZodOptional<z.ZodType<AdditionalMetroConfig & MetroDevServerConfig, z.ZodTypeDef, AdditionalMetroConfig & MetroDevServerConfig>>;
+    plugins: z.ZodType<PluginInput, z.ZodTypeDef, PluginInput>;
+}, "strip", z.ZodTypeAny, {
+    appName: string;
+    scheme: string;
+    cwd: string;
+    outdir: string;
+    entryFile: string;
+    plugins: PluginInput;
+    build?: BuildConfig | undefined;
+    metro?: (AdditionalMetroConfig & MetroDevServerConfig) | undefined;
+    devServer?: DevServerConfig | undefined;
+}, {
+    appName: string;
+    scheme: string;
+    plugins: PluginInput;
+    build?: BuildConfig | undefined;
+    metro?: (AdditionalMetroConfig & MetroDevServerConfig) | undefined;
+    cwd?: string | undefined;
+    outdir?: string | undefined;
+    entryFile?: string | undefined;
+    devServer?: DevServerConfig | undefined;
+}>;
+type GraniteConfig = z.input<typeof graniteConfigSchema>;
+type CompleteGraniteConfig = Omit<z.output<typeof graniteConfigSchema>, 'build' | 'plugins'> & {
+    build: Omit<BuildConfig$1, 'platform' | 'outfile'>;
+    pluginHooks: GranitePluginHooks;
+};
+interface GranitePluginHooks {
+    devServer: {
+        preHandlers: GranitePluginDevPreHandler[];
+        postHandlers: GranitePluginDevPostHandler[];
+    };
+    build: {
+        preHandlers: GranitePluginBuildPreHandler[];
+        postHandlers: GranitePluginBuildPostHandler[];
+    };
+}
+/**
+ * @public
+ * @category Configuration
+ * @name defineConfig
+ * @description
+ * Configures your Granite application by defining key settings in `granite.config.ts`.
+ *
+ * The configuration lets you specify:
+ * - How users will access your app through a URL scheme (e.g. `granite://`)
+ * - Your app's unique name that appears in the URL (e.g. `granite://my-service`)
+ * - Build settings for bundlers like ESBuild and Metro
+ * - Code transformation settings through Babel
+ * - Additional functionality through Granite plugins
+ *
+ * @param config - Configuration options
+ * @param config.cwd - Working directory for build process (defaults to process.cwd())
+ * @param config.appName - Your app's unique identifier
+ * @param config.scheme - URL scheme for launching your app (e.g. 'granite')
+ * @param config.outdir - Where to output build files (defaults to 'dist')
+ * @param config.entryFile - Your app's entry point (defaults to './src/_app.tsx')
+ * @param config.build - Customize build settings
+ * @param config.metro - Configure Metro bundler settings
+ * @param config.devServer - Configure Mpack dev server settings
+ * @param config.plugins - Granite plugins to enhance functionality
+ * @returns The processed configuration
+ *
+ * @example
+ * Here's a basic configuration that:
+ * - Makes your app accessible via the `granite://` scheme
+ * - Names your service "my-app" so it's reachable at `granite://my-app`
+ * - Uses the Hermes plugin to optimize JavaScript bundles into bytecode
+ *
+ * ```ts
+ * import { defineConfig } from '@granite-js/react-native/config';
+ * import { hermes } from '@granite-js/plugin-hermes';
+ *
+ * export default defineConfig({
+ *   // The name of your microservice
+ *   appName: 'my-app',
+ *   // The URL scheme for deep linking
+ *   scheme: 'granite',
+ *   // Entry file path
+ *   entryFile: 'index.ts',
+ *   // Array of plugins to use
+ *   plugins: [hermes()],
+ * });
+ * ```
+ */
+declare const defineConfig: (config: GraniteConfig) => Promise<CompleteGraniteConfig>;
+
+declare const loadConfig: () => Promise<CompleteGraniteConfig>;
+
+declare function initialize(): Promise<void>;
+
+export { type CompleteGraniteConfig, type GraniteConfig, type GranitePluginHooks, defineConfig, initialize, loadConfig };

package/dist/index.js

@@ -0,0 +1,389 @@
+import { createRequire } from 'module'; const require = createRequire(import.meta.url);
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/index.ts
+import { Builtins, Cli } from "clipanion";
+import { cosmiconfig as cosmiconfig2 } from "cosmiconfig";
+
+// src/commands/BuildCommand/BuildCommand.ts
+import { Command, Option } from "clipanion";
+
+// src/commands/BuildCommand/build.ts
+import path from "path";
+import { runBundle } from "@granite-js/mpack";
+import { statusPlugin } from "@granite-js/mpack/plugins";
+import { createContext } from "@granite-js/plugin-core";
+async function build(config, options) {
+  const pluginContext = createContext();
+  for (const preHandler of config.pluginHooks.build.preHandlers) {
+    await preHandler.call(pluginContext, {
+      cwd: config.cwd,
+      entryFile: config.entryFile,
+      appName: config.appName,
+      outdir: config.outdir
+    });
+  }
+  const buildResults = await Promise.all(
+    ["ios", "android"].map(
+      (platform) => runBundle({
+        rootDir: config.cwd,
+        dev: false,
+        metafile: true,
+        cache: options.cache,
+        plugins: [statusPlugin],
+        buildConfig: { platform, outfile: path.join(config.outdir, `bundle.${platform}.js`), ...config.build }
+      })
+    )
+  );
+  for (const postHandler of config.pluginHooks.build.postHandlers) {
+    await postHandler.call(pluginContext, {
+      cwd: config.cwd,
+      entryFile: config.entryFile,
+      appName: config.appName,
+      outdir: config.outdir,
+      buildResults
+    });
+  }
+}
+
+// src/config/loadConfig.ts
+import { getPackageRoot } from "@granite-js/utils";
+import { cosmiconfig } from "cosmiconfig";
+import { TypeScriptLoader } from "cosmiconfig-typescript-loader";
+var MODULE_NAME = "granite";
+var loadConfig = async () => {
+  const explorer = cosmiconfig(MODULE_NAME, {
+    searchPlaces: [
+      `${MODULE_NAME}.config.ts`,
+      `${MODULE_NAME}.config.mts`,
+      `${MODULE_NAME}.config.js`,
+      `${MODULE_NAME}.config.cjs`
+    ],
+    loaders: {
+      ".ts": TypeScriptLoader(),
+      ".mts": TypeScriptLoader()
+    }
+  });
+  const result = await explorer.search(getPackageRoot());
+  const config = await result?.config;
+  return config;
+};
+
+// src/commands/BuildCommand/BuildCommand.ts
+var BuildCommand = class extends Command {
+  static paths = [[`build`]];
+  static usage = Command.Usage({
+    category: "Build",
+    description: "Build Granite App",
+    examples: [["Build Granite App", "granite build"]]
+  });
+  disableCache = Option.Boolean("--disable-cache", {
+    description: "Disable cache"
+  });
+  async execute() {
+    try {
+      const { disableCache = false } = this;
+      const config = await loadConfig();
+      await build(config, {
+        cache: !disableCache
+      });
+      return 0;
+    } catch (error) {
+      console.error(error);
+      return 1;
+    }
+  }
+};
+
+// src/commands/HermesCommand/HermesCommand.ts
+import path3 from "path";
+import chalk from "chalk";
+import { Command as Command2, Option as Option2 } from "clipanion";
+
+// src/utils/compileHbc.ts
+import assert from "assert";
+import os from "os";
+import path2 from "path";
+import { isNotNil } from "es-toolkit";
+import execa from "execa";
+var binary = {
+  Darwin: "react-native/sdks/hermesc/osx-bin/hermesc",
+  Linux: "react-native/sdks/hermesc/linux64-bin/hermesc",
+  Windows_NT: "react-native/sdks/hermesc/win64-bin/hermesc.exe"
+};
+async function compileHbc({ rootDir, filePath, sourcemap }) {
+  const binary2 = getHermesc(rootDir);
+  const outfile = path2.resolve(rootDir, filePath.replace(new RegExp(`${path2.extname(filePath)}$`), ".hbc"));
+  await execa(
+    binary2,
+    [
+      // Disable warnings
+      "-w",
+      // Expensive optimizations
+      "-O",
+      // Emit binary
+      "-emit-binary",
+      // Emit source map
+      sourcemap ? "-output-source-map" : null,
+      // Output path
+      "-out",
+      outfile,
+      filePath
+    ].filter(isNotNil)
+  );
+  return { outfile, sourcemapOutfile: sourcemap ? `${outfile}.map` : null };
+}
+function getHermesc(rootDir) {
+  const os2 = getOs();
+  const binarySource = binary[os2];
+  assert(binarySource, `\uC9C0\uC6D0\uD558\uC9C0 \uC54A\uB294 OS \uC785\uB2C8\uB2E4: ${os2}`);
+  return resolveFromRoot(rootDir, binarySource);
+}
+function getOs() {
+  return os.type();
+}
+function resolveFromRoot(rootDir, request) {
+  return __require.resolve(request, { paths: [rootDir] });
+}
+
+// src/commands/HermesCommand/HermesCommand.ts
+var HermesCommand = class extends Command2 {
+  static paths = [[`hermes`]];
+  static usage = Command2.Usage({
+    category: "Hermes",
+    description: "\uC9C0\uC815\uD55C \uBC88\uB4E4\uC744 Hermes \uBC14\uC774\uD2B8 \uCF54\uB4DC\uB85C \uCEF4\uD30C\uC77C \uD569\uB2C8\uB2E4",
+    examples: [["\uCEF4\uD30C\uC77C\uD558\uAE30", "granite hermes --jsbundle dist/bundle.js"]]
+  });
+  jsBundleFile = Option2.String("--jsbundle", {
+    required: true,
+    description: "Hermes \uBC14\uC774\uD2B8 \uCF54\uB4DC\uB85C \uCEF4\uD30C\uC77C \uD560 Javascript \uD30C\uC77C \uACBD\uB85C \uC785\uB2C8\uB2E4"
+  });
+  sourcemap = Option2.Boolean("--sourcemap", true, {
+    description: "\uC18C\uC2A4\uB9F5 \uD30C\uC77C\uC744 \uC0DD\uC131\uD569\uB2C8\uB2E4"
+  });
+  async execute() {
+    try {
+      const rootDir = process.cwd();
+      const filePath = path3.resolve(rootDir, this.jsBundleFile);
+      const { outfile, sourcemapOutfile } = await compileHbc({ rootDir, filePath, sourcemap: this.sourcemap });
+      console.log(`\u2705 \uCEF4\uD30C\uC77C \uC644\uB8CC: ${chalk.gray(outfile)}`);
+      if (sourcemapOutfile) {
+        console.log(`\u2705 \uC18C\uC2A4\uB9F5 \uC0DD\uC131 \uC644\uB8CC: ${chalk.gray(sourcemapOutfile)}`);
+      }
+      return 0;
+    } catch (error) {
+      console.error(error.stack);
+      return 1;
+    }
+  }
+};
+
+// src/commands/DevCommand/DevCommand.ts
+import * as mpack from "@granite-js/mpack";
+import { Command as Command3, Option as Option3 } from "clipanion";
+import Debug from "debug";
+
+// src/commands/DevCommand/startDevServer.ts
+import { runServer } from "@granite-js/mpack";
+import { createContext as createContext2 } from "@granite-js/plugin-core";
+async function startDevServer(serverOptions, config) {
+  const pluginContext = createContext2();
+  const commonHandlerArgs = {
+    host: serverOptions.host,
+    port: serverOptions.port,
+    appName: config.appName,
+    outdir: config.outdir,
+    cwd: config.cwd,
+    entryFile: config.build.entry
+  };
+  for (const preHandler of config.pluginHooks.devServer.preHandlers) {
+    await preHandler.call(pluginContext, commonHandlerArgs);
+  }
+  await runServer({
+    cwd: config.cwd,
+    host: serverOptions.host,
+    port: serverOptions.port,
+    middlewares: config.metro?.middlewares,
+    enableEmbeddedReactDevTools: !serverOptions.disableEmbeddedReactDevTools,
+    additionalConfig: config.metro,
+    onServerReady: async () => {
+      for (const postHandler of config.pluginHooks.devServer.postHandlers) {
+        await postHandler.call(pluginContext, commonHandlerArgs);
+      }
+    }
+  });
+}
+
+// src/commands/DevCommand/DevCommand.ts
+var debug = Debug("cli");
+var DEFAULT_HOST = "0.0.0.0";
+var DEFAULT_LOCALHOST_PORT = 8081;
+var DevCommand = class extends Command3 {
+  static paths = [[`dev`]];
+  static usage = Command3.Usage({
+    category: "Development",
+    description: "Run Granite development server",
+    examples: [["Run Granite development server", "granite dev"]]
+  });
+  host = Option3.String("--host");
+  port = Option3.String("--port");
+  disableEmbeddedReactDevTools = Option3.Boolean("--disable-embedded-react-devtools", false);
+  // mpack dev-server
+  experimentalMode = Option3.Boolean("--experimental-mode");
+  async execute() {
+    try {
+      process.env.MPACK_DEV_SERVER = "true";
+      const config = await loadConfig();
+      const serverOptions = {
+        host: this.host,
+        port: this.port ? parseInt(this.port, 10) : void 0
+      };
+      debug("StartCommand", {
+        ...serverOptions,
+        disableEmbeddedReactDevTools: this.disableEmbeddedReactDevTools,
+        experimentalMode: this.experimentalMode
+      });
+      if (this.experimentalMode) {
+        await mpack.EXPERIMENTAL__runServer({
+          buildConfig: config.build,
+          host: serverOptions.host,
+          port: serverOptions.port
+        });
+      } else {
+        await startDevServer(
+          {
+            host: serverOptions.host || DEFAULT_HOST,
+            port: serverOptions.port || DEFAULT_LOCALHOST_PORT,
+            disableEmbeddedReactDevTools: this.disableEmbeddedReactDevTools
+          },
+          config
+        );
+      }
+    } catch (error) {
+      console.log(`ERROR OCCURRED`);
+      console.log(error);
+      console.log(error.message);
+      console.error(error.stack);
+      process.exit(1);
+    }
+  }
+};
+
+// src/config/defineConfig.ts
+import path5 from "path";
+import {
+  resolvePlugins,
+  mergeConfig
+} from "@granite-js/plugin-core";
+import { getPackageRoot as getPackageRoot2 } from "@granite-js/utils";
+import { isNotNil as isNotNil2 } from "es-toolkit";
+import { z } from "zod";
+
+// src/config/graniteGlobals.ts
+import fs from "fs";
+import path4 from "path";
+import { getLocalTempDirectoryPath, prepareLocalDirectory } from "@granite-js/utils";
+function prepareGraniteGlobalsScript(config) {
+  const filePath = writeGraniteGlobalsScript(config);
+  return {
+    esbuild: {
+      prelude: [filePath]
+    },
+    metro: {
+      prelude: [filePath]
+    }
+  };
+}
+function writeGraniteGlobalsScript(config) {
+  const script = getGraniteGlobalScript(config);
+  const filePath = path4.join(getLocalTempDirectoryPath(config.rootDir), "granite-globals.js");
+  prepareLocalDirectory(config.rootDir);
+  fs.writeFileSync(filePath, script, "utf-8");
+  return filePath;
+}
+function getGraniteGlobalScript({ appName, scheme }) {
+  return [
+    "global.__granite = global.__granite || {};",
+    `global.__granite.app = { name: ${JSON.stringify(appName)}, scheme: ${JSON.stringify(scheme)} };`
+  ].join("\n");
+}
+
+// src/config/defineConfig.ts
+var graniteConfigSchema = z.object({
+  cwd: z.string().default(process.cwd()),
+  appName: z.string(),
+  scheme: z.string(),
+  outdir: z.string().default("dist"),
+  entryFile: z.string().default("./src/_app.tsx"),
+  build: z.custom().optional(),
+  devServer: z.custom().optional(),
+  metro: z.custom().optional(),
+  plugins: z.custom()
+});
+var defineConfig = async (config) => {
+  const parsed = graniteConfigSchema.parse(config);
+  const cwd = parsed.cwd ?? getPackageRoot2();
+  const appName = parsed.appName;
+  const scheme = parsed.scheme;
+  const entryFile = path5.resolve(cwd, parsed.entryFile);
+  const outdir = path5.join(cwd, parsed.outdir);
+  const parsedBuildConfig = parsed.build;
+  const parsedDevServerConfig = parsed.devServer;
+  const parsedMetroConfig = parsed.metro;
+  const parsedConfig = {
+    ...parsedBuildConfig,
+    devServer: parsedDevServerConfig,
+    metro: parsedMetroConfig
+  };
+  const { configs, pluginHooks } = await resolvePlugins(parsed.plugins);
+  const globalsScriptConfig = prepareGraniteGlobalsScript({ rootDir: cwd, appName, scheme });
+  const mergedConfig = mergeConfig(parsedConfig, ...[globalsScriptConfig, ...configs].filter(isNotNil2));
+  const { metro, devServer, ...buildConfig } = mergedConfig ?? {};
+  return {
+    cwd,
+    entryFile,
+    appName,
+    scheme,
+    outdir,
+    devServer,
+    pluginHooks,
+    build: {
+      ...buildConfig,
+      entry: entryFile
+    },
+    metro: {
+      ...metro,
+      babelConfig: mergedConfig?.babel,
+      transformSync: mergedConfig?.transformer?.transformSync
+    }
+  };
+};
+
+// src/index.ts
+var cli = new Cli({
+  binaryLabel: "granite",
+  binaryName: "granite",
+  enableCapture: true
+});
+async function initialize() {
+  const explorer = await cosmiconfig2("mpack");
+  const result = await explorer.search(process.cwd());
+  cli.register(BuildCommand);
+  cli.register(HermesCommand);
+  cli.register(DevCommand);
+  cli.register(Builtins.HelpCommand);
+  if (Array.isArray(result?.config?.commands)) {
+    (result?.config?.commands).forEach((command) => cli.register(command));
+  }
+  cli.runExit(process.argv.slice(2));
+}
+export {
+  defineConfig,
+  initialize,
+  loadConfig
+};

package/package.json

@@ -0,0 +1,65 @@
+{
+  "name": "@granite-js/cli",
+  "type": "module",
+  "version": "0.0.0-dev-20250725013859",
+  "description": "The Granite CLI",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "require": "./dist/index.cjs",
+      "import": "./dist/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "scripts": {
+    "bin": "node scripts/run.js",
+    "prepack": "yarn build",
+    "typecheck": "tsc --noEmit",
+    "lint": "eslint .",
+    "find-deadcode": "ts-prune",
+    "build": "tsup"
+  },
+  "files": [
+    "dist",
+    "package.json"
+  ],
+  "devDependencies": {
+    "@babel/core": "^7.24.9",
+    "@babel/preset-env": "^7.24.8",
+    "@babel/preset-typescript": "^7.24.7",
+    "@types/babel__core": "^7",
+    "@types/babel__preset-env": "^7",
+    "@types/connect": "^3",
+    "@types/debug": "^4",
+    "@types/node": "^22.10.2",
+    "@types/serve-static": "^1",
+    "esbuild": "^0.25.4",
+    "eslint": "^9.7.0",
+    "ts-prune": "^0.10.3",
+    "tsup": "^8.5.0",
+    "typescript": "5.8.3",
+    "vitest": "^3.0.7"
+  },
+  "dependencies": {
+    "@granite-js/mpack": "workspace:*",
+    "@granite-js/plugin-core": "workspace:*",
+    "@granite-js/utils": "workspace:*",
+    "@inquirer/prompts": "^7.2.3",
+    "@shopify/semaphore": "^3.1.0",
+    "chalk": "^4",
+    "clipanion": "^4.0.0-rc.4",
+    "connect": "^3.7.0",
+    "cosmiconfig": "^9.0.0",
+    "cosmiconfig-typescript-loader": "^5.1.0",
+    "debug": "^4.3.7",
+    "enquirer": "^2.4.1",
+    "es-toolkit": "^1.32.0",
+    "execa": "^5",
+    "ora": "^5",
+    "typanion": "^3.14.0",
+    "zod": "3.24.4"
+  }
+}