@granite-js/mpack 0.1.7 → 0.1.8

package/CHANGELOG.md

@@ -1,5 +1,15 @@
 # @granite-js/mpack
 
+## 0.1.8
+
+### Patch Changes
+
+- b69366c: improve config structure
+- Updated dependencies [b69366c]
+  - @granite-js/plugin-core@0.1.8
+  - @granite-js/devtools-frontend@0.1.8
+  - @granite-js/utils@0.1.8
+
 ## 0.1.7
 
 ### Patch Changes

package/dist/bundler/Bundler.d.ts

@@ -1,4 +1,4 @@
-import type { BuildResult } from './types';
+import type { BuildResult } from '@granite-js/plugin-core';
 import { BundlerConfig, INTERNAL__Id } from '../types';
 import { Plugin } from '../types/Plugin';
 export declare class Bundler {

package/dist/bundler/Bundler.js

@@ -145,8 +145,8 @@ class Bundler {
         (0, import_plugins.requireContextPlugin)(),
         (0, import_plugins.transformPlugin)({
           context: pluginContext,
-          transformSync: buildConfig.transformSync,
-          transformAsync: buildConfig.transformAsync
+          transformSync: buildConfig.transformer?.transformSync,
+          transformAsync: buildConfig.transformer?.transformAsync
         }),
         ...esbuildOptions?.plugins ?? []
       ].filter(import_es_toolkit.isNotNil)

package/dist/bundler/internal/presets.d.ts

@@ -1,4 +1,5 @@
-import { BuildConfig, BundlerConfig } from '../../types';
+import { type BuildConfig } from '@granite-js/plugin-core';
+import type { BundlerConfig } from '../../types';
 export declare function getReactNativeSetupScripts({ rootDir }: {
     rootDir: string;
 }): string[];

package/dist/bundler/internal/presets.js

@@ -35,7 +35,7 @@ __export(presets_exports, {
 });
 module.exports = __toCommonJS(presets_exports);
 var import_path = __toESM(require("path"));
-var import_mergeBuildConfigs = require("../../utils/mergeBuildConfigs");
+var import_plugin_core = require("@granite-js/plugin-core");
 function getReactNativeSetupScripts({ rootDir }) {
   const reactNativePath = import_path.default.dirname(
     require.resolve("react-native/package.json", {
@@ -62,7 +62,7 @@ function defineGlobalVariables({ dev }) {
   };
 }
 function combineWithBaseBuildConfig(config, context) {
-  return (0, import_mergeBuildConfigs.mergeBuildConfigs)(
+  return (0, import_plugin_core.mergeBuildConfigs)(
     {
       entry: config.buildConfig.entry,
       outfile: config.buildConfig.outfile,
@@ -73,8 +73,6 @@ function combineWithBaseBuildConfig(config, context) {
         banner: {
           js: [
             globalVariables({ dev: context.dev }),
-            "global.__granite = global.__granite || {};",
-            `global.__granite.app = { name: ${JSON.stringify(config.appName)}, scheme: ${JSON.stringify(config.scheme)} };`,
             // symbol-asynciterator polyfill (ES5)
             `(function(){if(typeof Symbol!=="undefined"&&!Symbol.asyncIterator){Symbol.asyncIterator=Symbol.for("@@asyncIterator")}})();`
           ].join("\n")

package/dist/bundler/plugins/buildStatusPlugin/buildStatusPlugin.d.ts

@@ -1,6 +1,6 @@
+import type { BuildResult } from '@granite-js/plugin-core';
 import * as esbuild from 'esbuild';
-import { BuildResult } from '../../types';
-import { PluginOptions } from '../types';
+import type { PluginOptions } from '../types';
 export interface BuildStatusPluginOptions {
     onPrepare: () => void | Promise<void>;
     onStart: () => void | Promise<void>;

package/dist/bundler/plugins/buildStatusPlugin/buildStatusPlugin.js

@@ -31,11 +31,11 @@ function buildStatusPlugin({ context, ...hooks }) {
       let buildStartedAt = 0;
       let moduleCount = 0;
       build.onStart(async () => {
-        import_logger.logger.debug("\uBE4C\uB4DC \uC900\uBE44 \uC911", { id: context.id });
+        import_logger.logger.debug("Preparing build", { id: context.id });
         await hooks.onPrepare();
         moduleCount = 0;
         buildStartedAt = performance.now();
-        import_logger.logger.debug("\uBE4C\uB4DC \uC2DC\uC791", { id: context.id, buildStartedAt });
+        import_logger.logger.debug("Build started", { id: context.id, buildStartedAt });
         await hooks.onStart();
       });
       build.onLoad({ filter: /.*/ }, async () => {
@@ -44,13 +44,12 @@ function buildStatusPlugin({ context, ...hooks }) {
       });
       build.onEnd(async (result) => {
         const endAt = performance.now();
-        const { tag, buildConfig } = context.config;
+        const { buildConfig } = context.config;
         const { outfile, sourcemapOutfile, platform, extra } = buildConfig;
         const { source, sourcemap } = (0, import_getBundleOutputs.getBundleOutputs)(outfile, result);
         const duration = endAt - buildStartedAt;
         if (source && sourcemap) {
           Object.defineProperties(result, {
-            tag: { value: tag, enumerable: true },
             bundle: { value: { source, sourcemap }, enumerable: true },
             outfile: { value: outfile, enumerable: true },
             sourcemapOutfile: { value: sourcemapOutfile ?? (0, import_getSourcemapName.getSourcemapName)(outfile), enumerable: true },
@@ -60,7 +59,7 @@ function buildStatusPlugin({ context, ...hooks }) {
             duration: { value: duration, enumerable: true },
             size: { value: source.contents.byteLength, enumerable: true }
           });
-          import_logger.logger.debug("\uBE4C\uB4DC \uC644\uB8CC", { id: context.id, tag });
+          import_logger.logger.debug("Build completed", { id: context.id });
           await hooks.onEnd(result);
         } else {
           throw new Error("invalid bundle result");

package/dist/bundler/plugins/dependencyAliasPlugin/aliasResolver.d.ts

@@ -1,3 +1,3 @@
+import type { AliasConfig } from '@granite-js/plugin-core';
 import type { PluginBuild } from 'esbuild';
-import type { AliasConfig } from '../../../types';
 export declare function setupAliasResolver(build: PluginBuild, rootDir: string, aliasConfig: AliasConfig[]): void;

package/dist/bundler/plugins/dependencyAliasPlugin/protocolResolver.d.ts

@@ -1,3 +1,3 @@
+import type { ProtocolConfig } from '@granite-js/plugin-core';
 import type { PluginBuild } from 'esbuild';
-import type { ProtocolConfig } from '../../../types';
 export declare function setupProtocolResolver(build: PluginBuild, protocolConfig: ProtocolConfig): void;

package/dist/bundler/plugins/shared/swc.d.ts

@@ -1,5 +1,5 @@
+import type { AliasConfig } from '@granite-js/plugin-core';
 import type { JscConfig } from '@swc/core';
-import type { AliasConfig } from '../../../types';
 /**
  * `@swc/helpers`를 사용하여 번들 크기를 최적화 하기 위한 구성입니다.
  *

package/dist/bundler/plugins/transformPlugin/steps/createTransformToHermesSyntaxStep.d.ts

@@ -1,5 +1,5 @@
+import type { BuildConfig } from '@granite-js/plugin-core';
 import { AsyncTransformStep } from '../../../../transformer/TransformPipeline';
-import { BuildConfig } from '../../../../types';
 interface TransformToHermesSyntaxStepConfig {
     dev: boolean;
     additionalSwcOptions?: BuildConfig['swc'];

package/dist/constants/index.d.ts

@@ -5,7 +5,7 @@ export declare const MPACK_DATA_DIR: string;
 export declare const MPACK_CACHE_DIR: string;
 export declare const SOURCE_EXTENSIONS: readonly [".tsx", ".ts", ".jsx", ".js", ".json"];
 export declare const ASSET_EXTENSIONS: readonly [".png", ".jpg", ".jpeg", ".gif", ".webp", ".svg"];
-export declare const DEV_SERVER_DEFAULT_HOST = "localhost";
+export declare const DEV_SERVER_DEFAULT_HOST = "0.0.0.0";
 export declare const DEV_SERVER_DEFAULT_PORT = 8081;
 /**
  * 제거 필요: `SHARED_BUNDLE_NAME`, `SERVICE_BUNDLE_NAME` -> `BUNDLE_NAME`

package/dist/constants/index.js

@@ -59,7 +59,7 @@ const MPACK_DATA_DIR = path.join(TEMP_DIR, "data");
 const MPACK_CACHE_DIR = path.join(TEMP_DIR, "cache");
 const SOURCE_EXTENSIONS = [".tsx", ".ts", ".jsx", ".js", ".json"];
 const ASSET_EXTENSIONS = [".png", ".jpg", ".jpeg", ".gif", ".webp", ".svg"];
-const DEV_SERVER_DEFAULT_HOST = "localhost";
+const DEV_SERVER_DEFAULT_HOST = "0.0.0.0";
 const DEV_SERVER_DEFAULT_PORT = 8081;
 const SHARED_BUNDLE_NAME = (0, import_getBundleName.getBundleName)("index");
 const SERVICE_BUNDLE_NAME = (0, import_getBundleName.getBundleName)("service");

package/dist/index.d.ts

@@ -1,9 +1,6 @@
 export { Bundler } from './bundler';
 export { DevServer } from './server';
-export { getMetroConfig, runBuild as metroBuild, type MetroConfig } from './metro';
+export { BuildUtils, runServer, EXPERIMENTAL__server } from './operations';
+export { getMetroConfig, MetroBuildUtils } from './metro';
 export { DEV_SERVER_DEFAULT_HOST, DEV_SERVER_DEFAULT_PORT, SHARED_BUNDLE_NAME, SERVICE_BUNDLE_NAME, BUNDLE_NAME, } from './constants';
-export * from './operations';
-export * from './types/schemas';
-export * from './types';
-export type { AdditionalMetroConfig } from './metro/getMetroConfig';
-export type { BuildResult } from './bundler/types';
+export type * from './types';

package/dist/index.js

@@ -15,40 +15,40 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
-var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var index_exports = {};
 __export(index_exports, {
   BUNDLE_NAME: () => import_constants.BUNDLE_NAME,
+  BuildUtils: () => import_operations.BuildUtils,
   Bundler: () => import_bundler.Bundler,
   DEV_SERVER_DEFAULT_HOST: () => import_constants.DEV_SERVER_DEFAULT_HOST,
   DEV_SERVER_DEFAULT_PORT: () => import_constants.DEV_SERVER_DEFAULT_PORT,
   DevServer: () => import_server.DevServer,
+  EXPERIMENTAL__server: () => import_operations.EXPERIMENTAL__server,
+  MetroBuildUtils: () => import_metro.MetroBuildUtils,
   SERVICE_BUNDLE_NAME: () => import_constants.SERVICE_BUNDLE_NAME,
   SHARED_BUNDLE_NAME: () => import_constants.SHARED_BUNDLE_NAME,
   getMetroConfig: () => import_metro.getMetroConfig,
-  metroBuild: () => import_metro.runBuild
+  runServer: () => import_operations.runServer
 });
 module.exports = __toCommonJS(index_exports);
 var import_bundler = require("./bundler");
 var import_server = require("./server");
+var import_operations = require("./operations");
 var import_metro = require("./metro");
 var import_constants = require("./constants");
-__reExport(index_exports, require("./operations"), module.exports);
-__reExport(index_exports, require("./types/schemas"), module.exports);
-__reExport(index_exports, require("./types"), module.exports);
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   BUNDLE_NAME,
+  BuildUtils,
   Bundler,
   DEV_SERVER_DEFAULT_HOST,
   DEV_SERVER_DEFAULT_PORT,
   DevServer,
+  EXPERIMENTAL__server,
+  MetroBuildUtils,
   SERVICE_BUNDLE_NAME,
   SHARED_BUNDLE_NAME,
   getMetroConfig,
-  metroBuild,
-  ...require("./operations"),
-  ...require("./types/schemas"),
-  ...require("./types")
+  runServer
 });

package/dist/metro/build.d.ts

@@ -0,0 +1,17 @@
+import { BuildResult, type CompleteGraniteConfig } from '@granite-js/plugin-core';
+interface CommonMetroBuildOptions {
+    outfile?: string;
+    dev?: boolean;
+    minify?: boolean;
+    platform: 'ios' | 'android';
+}
+export interface MetroBuildOptions extends CommonMetroBuildOptions {
+    config: CompleteGraniteConfig;
+}
+export interface MetroBuildAllOptions {
+    config: CompleteGraniteConfig;
+    concurrency?: number;
+}
+export declare function build({ config, ...options }: MetroBuildOptions): Promise<BuildResult>;
+export declare function buildAll(optionsList: CommonMetroBuildOptions[], { config, concurrency }: MetroBuildAllOptions): Promise<BuildResult[]>;
+export {};

package/dist/metro/build.js

@@ -0,0 +1,104 @@
+"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);
+var build_exports = {};
+__export(build_exports, {
+  build: () => build,
+  buildAll: () => buildAll
+});
+module.exports = __toCommonJS(build_exports);
+var import_path = __toESM(require("path"));
+var import_plugin_core = require("@granite-js/plugin-core");
+var import_es_toolkit = require("es-toolkit");
+var import_getMetroConfig = require("./getMetroConfig");
+var import_src = __toESM(require("../vendors/metro/src"));
+async function build({ config, ...options }) {
+  const driver = (0, import_plugin_core.createPluginHooksDriver)(config);
+  await driver.build.pre();
+  const buildResult = await buildImpl(config, options);
+  await driver.build.post({
+    buildResults: [buildResult]
+  });
+  return buildResult;
+}
+async function buildAll(optionsList, { config, concurrency = 2 }) {
+  const buildResults = [];
+  const semaphore = new import_es_toolkit.Semaphore(Math.min(concurrency, optionsList.length));
+  const driver = (0, import_plugin_core.createPluginHooksDriver)(config);
+  await driver.build.pre();
+  for (const options of optionsList) {
+    await semaphore.acquire();
+    try {
+      const buildResult = await buildImpl(config, options);
+      buildResults.push(buildResult);
+    } catch {
+      semaphore.release();
+    }
+  }
+  await driver.build.post({ buildResults });
+  return buildResults;
+}
+async function buildImpl(config, { platform, outfile = `bundle.${platform}.js`, minify = false, dev = true }) {
+  const metroConfig = await (0, import_getMetroConfig.getMetroConfig)({ rootPath: config.cwd }, config.metro);
+  const out = import_path.default.join(config.outdir, outfile);
+  await import_src.default.runBuild(metroConfig, {
+    entry: config.entryFile,
+    out,
+    platform,
+    minify,
+    dev
+  });
+  return buildResultShim(config, { outfile, platform, minify, dev });
+}
+function buildResultShim(config, options) {
+  const unsupportedField = new Proxy({}, {
+    get: (_, key) => {
+      throw new Error(`Unsupported field: ${key.toString()}`);
+    }
+  });
+  return {
+    platform: options.platform,
+    bundle: unsupportedField,
+    outfile: import_path.default.join(config.outdir, options.outfile),
+    outputFiles: [{ path: options.outfile, contents: new Uint8Array(), hash: "", text: "" }],
+    sourcemapOutfile: "",
+    warnings: [],
+    errors: [],
+    extra: unsupportedField,
+    mangleCache: unsupportedField,
+    metafile: unsupportedField,
+    size: 0,
+    duration: 0,
+    totalModuleCount: 0
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  build,
+  buildAll
+});

package/dist/metro/getMetroConfig.d.ts

@@ -1,16 +1,5 @@
-import type * as babel from '@babel/core';
-import type { MetroConfig } from './types';
-import type { ReportableEvent } from '../vendors/metro/src/lib/ReportableEvent';
+import type { AdditionalMetroConfig } from '@granite-js/plugin-core';
 export interface GetMetroConfig {
     rootPath: string;
-    appName: string;
-    scheme: string;
 }
-export interface AdditionalMetroConfig extends MetroConfig {
-    transformSync?: (id: string, code: string) => string;
-    babelConfig?: babel.TransformOptions;
-    reporter?: {
-        update: (event: ReportableEvent) => void;
-    };
-}
-export declare function getMetroConfig({ rootPath, appName, scheme }: GetMetroConfig, additionalConfig?: AdditionalMetroConfig): Promise<any>;
+export declare function getMetroConfig({ rootPath }: GetMetroConfig, additionalConfig?: AdditionalMetroConfig): Promise<any>;

package/dist/metro/getMetroConfig.js

@@ -35,7 +35,6 @@ var import_path = __toESM(require("path"));
 var import_utils = require("@granite-js/utils");
 var import_enhancedResolver = require("./enhancedResolver");
 var import_getMonorepoRoot = require("./getMonorepoRoot");
-var import_runtime = require("./runtime");
 var import_constants = require("../constants");
 var import_defaults = require("../vendors/metro-config/src/defaults");
 var import_exclusionList = __toESM(require("../vendors/metro-config/src/defaults/exclusionList"));
@@ -59,12 +58,11 @@ const INTERNAL_CALLSITES_REGEX = new RegExp(
     "^\\[native code\\]$"
   ].join("|")
 );
-async function getMetroConfig({ rootPath, appName, scheme }, additionalConfig) {
+async function getMetroConfig({ rootPath }, additionalConfig) {
   const defaultConfig = (0, import_defaults.getDefaultValues)(rootPath);
   const reactNativePath = import_path.default.dirname(resolveFromRoot("react-native/package.json", rootPath));
   const resolvedRootPath = await (0, import_getMonorepoRoot.getMonorepoRoot)(rootPath);
   const packageRootPath = await (0, import_utils.getPackageRoot)();
-  const { path: envFilePath } = await (0, import_runtime.writeEnvScript)(packageRootPath, appName, scheme);
   return (0, import_loadConfig.mergeConfig)(defaultConfig, {
     watchFolders: [resolvedRootPath, packageRootPath],
     transformerPath: resolveVendors("metro-transform-worker/src"),
@@ -105,9 +103,8 @@ async function getMetroConfig({ rootPath, appName, scheme }, additionalConfig) {
     serializer: {
       getModulesRunBeforeMainModule: () => [resolveFromRoot("react-native/Libraries/Core/InitializeCore", rootPath)],
       getPolyfills: () => [
-        envFilePath,
-        ...additionalConfig?.serializer?.getPolyfills?.() ?? [],
-        ...require(import_path.default.join(reactNativePath, "rn-get-polyfills"))()
+        ...require(import_path.default.join(reactNativePath, "rn-get-polyfills"))(),
+        ...additionalConfig?.serializer?.getPolyfills?.() ?? []
       ]
     },
     symbolicator: {

package/dist/metro/index.d.ts

@@ -1,3 +1,2 @@
 export * from './getMetroConfig';
-export * from './runBuild';
-export type { MetroConfig } from './types';
+export * as MetroBuildUtils from './build';

package/dist/metro/index.js

@@ -1,8 +1,14 @@
 "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))
@@ -12,13 +18,24 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+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);
 var metro_exports = {};
+__export(metro_exports, {
+  MetroBuildUtils: () => MetroBuildUtils
+});
 module.exports = __toCommonJS(metro_exports);
 __reExport(metro_exports, require("./getMetroConfig"), module.exports);
-__reExport(metro_exports, require("./runBuild"), module.exports);
+var MetroBuildUtils = __toESM(require("./build"));
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  ...require("./getMetroConfig"),
-  ...require("./runBuild")
+  MetroBuildUtils,
+  ...require("./getMetroConfig")
 });

package/dist/operations/build.d.ts

@@ -0,0 +1,15 @@
+import { type BuildConfig, type BuildResult, type CompleteGraniteConfig } from '@granite-js/plugin-core';
+import type { BundlerConfig, PluginFactory } from '../types';
+type CommonBuildOptions = Omit<BundlerConfig, 'rootDir' | 'buildConfig'> & Pick<BuildConfig, 'platform' | 'outfile'>;
+export interface BuildOptions extends CommonBuildOptions {
+    config: CompleteGraniteConfig;
+    plugins?: PluginFactory[];
+}
+export interface BuildAllOptions {
+    config: CompleteGraniteConfig;
+    concurrency?: number;
+    plugins?: PluginFactory[];
+}
+export declare function build({ config, plugins, ...options }: BuildOptions): Promise<BuildResult>;
+export declare function buildAll(optionsList: CommonBuildOptions[], { config, plugins, concurrency }: BuildAllOptions): Promise<BuildResult[]>;
+export {};

package/dist/operations/{runBundle.js → build.js}

@@ -26,58 +26,72 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var runBundle_exports = {};
-__export(runBundle_exports, {
-  runBundle: () => runBundle
+var build_exports = {};
+__export(build_exports, {
+  build: () => build,
+  buildAll: () => buildAll
 });
-module.exports = __toCommonJS(runBundle_exports);
+module.exports = __toCommonJS(build_exports);
 var fs = __toESM(require("fs/promises"));
 var path = __toESM(require("path"));
-var import_semaphore = require("@shopify/semaphore");
+var import_plugin_core = require("@granite-js/plugin-core");
 var import_es_toolkit = require("es-toolkit");
 var import_bundler = require("../bundler");
 var import_performance = require("../performance");
 var import_writeBundle = require("../utils/writeBundle");
-async function runBundle(options) {
-  const config = options.config;
-  const semaphore = new import_semaphore.Semaphore(config.concurrency ?? 4);
-  const buildResults = await Promise.all(
-    config.tasks.map(async ({ tag, build }) => {
-      if (typeof options.tag === "string" && tag !== options.tag) {
-        return;
-      }
-      const bundler = new import_bundler.Bundler({
-        tag,
-        buildConfig: build,
-        appName: config.appName,
-        scheme: config.scheme,
-        services: config.services,
-        dev: options.dev,
-        metafile: options.metafile,
-        rootDir: options.rootDir,
-        cache: options.cache
-      });
-      if (options.plugins) {
-        options.plugins.forEach((fn) => bundler.addPlugin(fn()));
-      }
-      const permit = await semaphore.acquire();
+async function build({ config, plugins = [], ...options }) {
+  const driver = (0, import_plugin_core.createPluginHooksDriver)(config);
+  await driver.build.pre();
+  const buildResult = await buildImpl(config, plugins, options);
+  await driver.build.post({ buildResults: [buildResult] });
+  return buildResult;
+}
+async function buildAll(optionsList, { config, plugins = [], concurrency = 2 }) {
+  const buildResults = [];
+  const semaphore = new import_es_toolkit.Semaphore(Math.min(concurrency, optionsList.length));
+  const driver = (0, import_plugin_core.createPluginHooksDriver)(config);
+  await driver.build.pre();
+  await Promise.all(
+    optionsList.map(async (options) => {
+      await semaphore.acquire();
       try {
-        const result = await bundler.build();
-        await (0, import_writeBundle.writeBundle)(result.outfile, result.bundle);
-        return result;
-      } finally {
-        await permit.release();
+        const buildResult = await buildImpl(config, plugins, options);
+        buildResults.push(buildResult);
+      } catch {
+        semaphore.release();
       }
     })
-  ).then((results) => results.filter(import_es_toolkit.isNotNil));
+  );
+  await driver.build.post({ buildResults });
+  return buildResults;
+}
+async function buildImpl(config, plugins, { platform, outfile = `bundle.${platform}.js`, cache = true, dev = true, metafile = false }) {
+  const resolvedOutfile = path.join(config.outdir, outfile);
+  const bundler = new import_bundler.Bundler({
+    rootDir: config.cwd,
+    cache,
+    dev,
+    metafile,
+    buildConfig: {
+      platform,
+      outfile: resolvedOutfile,
+      ...config.build
+    }
+  });
+  for (const plugin of plugins) {
+    bundler.addPlugin(plugin());
+  }
+  const buildResult = await bundler.build();
+  await (0, import_writeBundle.writeBundle)(buildResult.outfile, buildResult.bundle);
   const performanceSummary = import_performance.Performance.getSummary();
   if (performanceSummary != null) {
     (0, import_performance.printSummary)(performanceSummary);
-    await fs.writeFile(path.join(options.rootDir, "perf.json"), JSON.stringify(performanceSummary, null, 2), "utf-8");
+    await fs.writeFile(path.join(config.cwd, "perf.json"), JSON.stringify(performanceSummary, null, 2), "utf-8");
   }
-  return buildResults;
+  return buildResult;
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  runBundle
+  build,
+  buildAll
 });

package/dist/operations/createDebuggerMiddleware.d.ts

@@ -1,10 +1,9 @@
 import connect from 'connect';
 interface DebuggerMiddlewareConfig {
-    host?: string;
     port: number;
     broadcastMessage: (method: string, params?: Record<string, unknown>) => void;
 }
-export declare function createDebuggerMiddleware({ host, port, broadcastMessage }: DebuggerMiddlewareConfig): {
+export declare function createDebuggerMiddleware({ port, broadcastMessage }: DebuggerMiddlewareConfig): {
     middleware: connect.Server;
     enableStdinWatchMode: () => void;
 };

package/dist/operations/createDebuggerMiddleware.js

@@ -45,7 +45,7 @@ var import_vendors = require("../vendors");
 const debug = (0, import_debug.default)("cli:start");
 const { InspectorProxy } = (0, import_vendors.getModule)("metro-inspector-proxy");
 const chromeInstanceMap = /* @__PURE__ */ new Map();
-function createDebuggerMiddleware({ host, port, broadcastMessage }) {
+function createDebuggerMiddleware({ port, broadcastMessage }) {
   const middleware = (0, import_connect.default)().use(`/${import_constants.DEBUGGER_FRONTEND_PATH}`, (0, import_serve_static.default)(import_path.default.resolve(import_devtools_frontend.default)));
   function enableStdinWatchMode() {
     if (!process.stdout.isTTY || process.stdin.setRawMode == null) {
@@ -80,14 +80,14 @@ function createDebuggerMiddleware({ host, port, broadcastMessage }) {
           broadcastMessage("devMenu");
           break;
         case "j":
-          openReactNativeDebugger(host, port);
+          openReactNativeDebugger(port);
           break;
       }
     });
   }
   return { middleware, enableStdinWatchMode };
 }
-async function openReactNativeDebugger(host = "localhost", port) {
+async function openReactNativeDebugger(port) {
   const connectedDevices = Array.from(InspectorProxy.devices.entries());
   let targetDevice;
   for (const [id, device] of connectedDevices) {
@@ -113,7 +113,7 @@ async function openReactNativeDebugger(host = "localhost", port) {
   }
   console.log(`Opening debugger for '${targetDevice.name}'...`);
   chromeInstanceMap.get(targetDevice.id)?.kill();
-  (0, import_openDebugger.openDebugger)(host, port, targetDevice.id.toString()).then((chrome) => {
+  (0, import_openDebugger.openDebugger)(port, targetDevice.id.toString()).then((chrome) => {
     chromeInstanceMap.set(targetDevice.id, chrome);
   }).catch((error) => {
     if (error.message.includes("ECONNREFUSED")) {

package/dist/operations/experimental/serve.d.ts

@@ -0,0 +1,11 @@
+import { CompleteGraniteConfig } from '@granite-js/plugin-core';
+interface RunServerArgs {
+    config: CompleteGraniteConfig;
+    host?: string;
+    port?: number;
+    onServerReady?: () => Promise<void> | void;
+}
+export declare function EXPERIMENTAL__server({ config, host, port, onServerReady, }: RunServerArgs): Promise<{
+    cleanup: () => Promise<void>;
+}>;
+export {};