@apps-in-toss/plugins 0.0.39 → 1.0.0

package/dist/internal.js

@@ -0,0 +1,935 @@
+import { createRequire } from 'module'; const require = createRequire(import.meta.url);
+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 __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');
+});
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __commonJS = (cb, mod) => function __require2() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+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
+));
+
+// ../../.yarn/__virtual__/tsup-virtual-5261887034/0/cache/tsup-npm-8.4.0-f78d2622c9-c6636ffd6a.zip/node_modules/tsup/assets/esm_shims.js
+var init_esm_shims = __esm({
+  "../../.yarn/__virtual__/tsup-virtual-5261887034/0/cache/tsup-npm-8.4.0-f78d2622c9-c6636ffd6a.zip/node_modules/tsup/assets/esm_shims.js"() {
+    "use strict";
+  }
+});
+
+// ../../.yarn/__virtual__/typia-virtual-93fdc6e779/0/cache/typia-npm-8.0.4-b2444b63f3-1028a8a121.zip/node_modules/typia/lib/internal/_isFormatUuid.js
+var require_isFormatUuid = __commonJS({
+  "../../.yarn/__virtual__/typia-virtual-93fdc6e779/0/cache/typia-npm-8.0.4-b2444b63f3-1028a8a121.zip/node_modules/typia/lib/internal/_isFormatUuid.js"(exports) {
+    "use strict";
+    init_esm_shims();
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports._isFormatUuid = void 0;
+    var _isFormatUuid2 = (str) => PATTERN.test(str);
+    exports._isFormatUuid = _isFormatUuid2;
+    var PATTERN = /^(?:urn:uuid:)?[0-9a-f]{8}-(?:[0-9a-f]{4}-){3}[0-9a-f]{12}$/i;
+  }
+});
+
+// ../../.yarn/__virtual__/typia-virtual-93fdc6e779/0/cache/typia-npm-8.0.4-b2444b63f3-1028a8a121.zip/node_modules/typia/lib/internal/_validateReport.js
+var require_validateReport = __commonJS({
+  "../../.yarn/__virtual__/typia-virtual-93fdc6e779/0/cache/typia-npm-8.0.4-b2444b63f3-1028a8a121.zip/node_modules/typia/lib/internal/_validateReport.js"(exports) {
+    "use strict";
+    init_esm_shims();
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports._validateReport = void 0;
+    var _validateReport2 = (array) => {
+      const reportable = (path9) => {
+        if (array.length === 0)
+          return true;
+        const last = array[array.length - 1].path;
+        return path9.length > last.length || last.substring(0, path9.length) !== path9;
+      };
+      return (exceptable, error) => {
+        if (exceptable && reportable(error.path))
+          array.push(error);
+        return false;
+      };
+    };
+    exports._validateReport = _validateReport2;
+  }
+});
+
+// src/internal.ts
+init_esm_shims();
+
+// src/appsInTossHost.ts
+init_esm_shims();
+import { microFrontend } from "@granite-js/plugin-micro-frontend";
+
+// src/constants.ts
+init_esm_shims();
+var REACT_NATIVE_VERSION = "0.72.6";
+var APP_MANIFEST_NAME = "app.json";
+var MICRO_FRONTEND_HOST_NAME = "apps-in-toss-host";
+var HOST_CONTEXT_IDENTIFIER = "__appsInTossHost";
+var SHRED_PACKAGES = [
+  "@react-native-community/blur",
+  "@react-navigation/native",
+  "@react-navigation/native-stack",
+  "@shopify/flash-list",
+  "lottie-react-native",
+  "react-native-safe-area-context",
+  "react-native-screens",
+  "react-native-fast-image",
+  "react-native-svg",
+  "react-native-gesture-handler",
+  "react-native",
+  "react",
+  "react-native-video",
+  "react-native-webview"
+];
+
+// src/plugins/index.ts
+init_esm_shims();
+
+// src/plugins/appJson.ts
+init_esm_shims();
+import fs from "node:fs";
+import path from "path";
+import { getPackageRoot } from "@granite-js/utils";
+async function appsInTossAppJson(options) {
+  const packageRoot = getPackageRoot();
+  const handleAppJson = async (appName) => {
+    const appJsonPath = path.join(packageRoot, ".granite", APP_MANIFEST_NAME);
+    const appJsonObject = {
+      appName,
+      permissions: options.permissions
+    };
+    await fs.promises.mkdir(path.dirname(appJsonPath), { recursive: true });
+    try {
+      const existingAppJson = await fs.promises.readFile(appJsonPath, "utf8");
+      const existingAppJsonObject = JSON.parse(existingAppJson);
+      Object.assign(appJsonObject, existingAppJsonObject, {
+        appName,
+        permissions: appJsonObject.permissions
+      });
+    } catch {
+    }
+    await fs.promises.writeFile(appJsonPath, JSON.stringify(appJsonObject, null, 2), "utf8");
+  };
+  return {
+    name: "apps-in-toss:app-json",
+    dev: {
+      order: "pre",
+      handler: async ({ appName }) => {
+        handleAppJson(appName);
+      }
+    },
+    build: {
+      order: "pre",
+      handler: async ({ appName }) => {
+        handleAppJson(appName);
+      }
+    }
+  };
+}
+
+// src/plugins/artifact.ts
+init_esm_shims();
+import path6 from "path";
+import { isBuildFailure, isBuildSuccess } from "@granite-js/plugin-core";
+import { getPackageRoot as getPackageRoot3 } from "@granite-js/utils";
+import pc2 from "picocolors";
+
+// src/log.ts
+init_esm_shims();
+import pc from "picocolors";
+var TAG = pc.bold(pc.cyan("[AppsInToss]"));
+function log(...args) {
+  console.log(TAG, ...args);
+}
+
+// src/utils/collectDependencyVersions.ts
+init_esm_shims();
+import * as fs2 from "fs/promises";
+import * as path2 from "path";
+import * as esbuild from "esbuild";
+async function collectDependencyVersions(rootDir) {
+  const packageJsonPath = path2.join(rootDir, "package.json");
+  const packageJson = JSON.parse(await fs2.readFile(packageJsonPath, "utf8"));
+  const [dependencies, devDependencies] = await Promise.all([
+    resolvePackageVersions(rootDir, Object.keys(packageJson.dependencies)),
+    resolvePackageVersions(rootDir, Object.keys(packageJson.devDependencies))
+  ]);
+  return { dependencies, devDependencies };
+}
+async function resolvePackageVersions(rootDir, packageNames) {
+  const results = {};
+  await esbuild.build({
+    stdin: { contents: createVirtualEntry(packageNames) },
+    bundle: true,
+    write: false,
+    logLevel: "silent",
+    plugins: [
+      {
+        name: "collect-package-version",
+        setup(build2) {
+          const RESOLVING = Symbol();
+          build2.onResolve({ filter: /.*/ }, async (args) => {
+            if (args.pluginData === RESOLVING) {
+              return null;
+            }
+            const resolveOptions = {
+              importer: args.importer,
+              kind: args.kind,
+              resolveDir: rootDir,
+              pluginData: RESOLVING
+            };
+            let result = await build2.resolve(path2.join(args.path, "package.json"), resolveOptions);
+            if (result.errors.length) {
+              result = await build2.resolve(args.path, resolveOptions);
+            }
+            if (result.errors.length) {
+              return result;
+            }
+            const packageName = args.path;
+            const packagePath = extractPackagePath(result.path, packageName);
+            if (packagePath) {
+              results[packageName] = await getPackageVersion(packagePath);
+            }
+            return result;
+          });
+          build2.onLoad({ filter: /.*/ }, () => ({ contents: "// empty source" }));
+        }
+      }
+    ]
+  });
+  return results;
+}
+function createVirtualEntry(packageNames) {
+  return packageNames.map((packageName) => `import '${packageName}';`).join("\n");
+}
+function extractPackagePath(path9, packageName) {
+  const normalizedPath = normalizePath(path9);
+  if (normalizedPath.endsWith("/package.json")) {
+    return normalizedPath.replace(/\/package\.json$/, "");
+  }
+  const match = normalizedPath.match(new RegExp(`(.*?node_modules/${packageName})/.*$`));
+  if (match) {
+    return match[1];
+  }
+  throw new Error(`Failed to extract path: ${packageName}`);
+}
+function normalizePath(path9) {
+  return path9.replace(/\\/g, "/");
+}
+async function getPackageVersion(packagePath) {
+  const packageJson = JSON.parse(await fs2.readFile(path2.join(packagePath, "package.json"), "utf-8"));
+  return packageJson.version;
+}
+
+// src/utils/createArtifact.ts
+init_esm_shims();
+import path5 from "path";
+import { readZipContent } from "@granite-js/utils";
+
+// src/utils/compressToZip.ts
+init_esm_shims();
+import * as fs3 from "fs";
+import * as path3 from "path";
+import archiver from "archiver";
+async function compressToZip(config) {
+  const { files, outfile } = config;
+  return new Promise((resolve, reject) => {
+    const outputStream = fs3.createWriteStream(outfile);
+    const archive = archiver("zip", { zlib: { level: 9 } });
+    outputStream.on("close", () => resolve(outfile));
+    outputStream.on("error", (error) => reject(error));
+    archive.on("error", (error) => reject(error)).pipe(outputStream);
+    files.forEach(({ path: filePath, name }) => {
+      const fileName = name ?? path3.basename(filePath);
+      archive.append(fs3.createReadStream(filePath), { name: fileName });
+    });
+    archive.finalize();
+  });
+}
+
+// src/utils/updateAppJsonMetadata.ts
+init_esm_shims();
+import * as fs4 from "fs/promises";
+import * as path4 from "path";
+import { getPackageRoot as getPackageRoot2 } from "@granite-js/utils";
+async function resolveAppManifestPath() {
+  const cwd = getPackageRoot2();
+  const appManifestPath = path4.join(cwd, ".granite", APP_MANIFEST_NAME);
+  await fs4.access(appManifestPath, fs4.constants.F_OK);
+  return appManifestPath;
+}
+async function readAppJson(appJsonPath) {
+  const appJson = await fs4.readFile(appJsonPath, "utf8");
+  return JSON.parse(appJson);
+}
+async function writeAppJson(appJsonPath, content) {
+  await fs4.writeFile(appJsonPath, JSON.stringify(content));
+}
+async function updateAppJsonMetadata(metadata) {
+  const appJsonPath = await resolveAppManifestPath();
+  const appJson = await readAppJson(appJsonPath);
+  await writeAppJson(appJsonPath, {
+    ...appJson,
+    _metadata: metadata
+  });
+}
+
+// src/types.ts
+init_esm_shims();
+var __typia_transform__isFormatUuid = __toESM(require_isFormatUuid(), 1);
+var __typia_transform__validateReport = __toESM(require_validateReport(), 1);
+var validateAppManifest = /* @__PURE__ */ (() => {
+  const _io0 = (input) => "string" === typeof input.appName && (Array.isArray(input.permissions) && input.permissions.every((elem) => "object" === typeof elem && null !== elem && _iu0(elem))) && ("object" === typeof input._metadata && null !== input._metadata && _io6(input._metadata));
+  const _io1 = (input) => "clipboard" === input.name && ("read" === input.access || "write" === input.access);
+  const _io2 = (input) => "geolocation" === input.name && "access" === input.access;
+  const _io3 = (input) => "contacts" === input.name && ("read" === input.access || "write" === input.access);
+  const _io4 = (input) => "photos" === input.name && ("read" === input.access || "write" === input.access);
+  const _io5 = (input) => "camera" === input.name && "access" === input.access;
+  const _io6 = (input) => Array.isArray(input.bundleFiles) && input.bundleFiles.every((elem) => "string" === typeof elem) && ("string" === typeof input.deploymentId && __typia_transform__isFormatUuid._isFormatUuid(input.deploymentId));
+  const _iu0 = (input) => (() => {
+    if ("camera" === input.name)
+      return _io5(input);
+    else if ("photos" === input.name)
+      return _io4(input);
+    else if ("contacts" === input.name)
+      return _io3(input);
+    else if ("geolocation" === input.name)
+      return _io2(input);
+    else if ("clipboard" === input.name)
+      return _io1(input);
+    else
+      return false;
+  })();
+  const _vo0 = (input, _path, _exceptionable = true) => ["string" === typeof input.appName || _report(_exceptionable, {
+    path: _path + ".appName",
+    expected: "string",
+    value: input.appName
+  }), (Array.isArray(input.permissions) || _report(_exceptionable, {
+    path: _path + ".permissions",
+    expected: "Array<Permission>",
+    value: input.permissions
+  })) && input.permissions.map((elem, _index3) => ("object" === typeof elem && null !== elem || _report(_exceptionable, {
+    path: _path + ".permissions[" + _index3 + "]",
+    expected: "(CameraPermission | ClipboardPermission | ContactsPermission | GeolocationPermission | PhotosPermission)",
+    value: elem
+  })) && _vu0(elem, _path + ".permissions[" + _index3 + "]", _exceptionable) || _report(_exceptionable, {
+    path: _path + ".permissions[" + _index3 + "]",
+    expected: "(CameraPermission | ClipboardPermission | ContactsPermission | GeolocationPermission | PhotosPermission)",
+    value: elem
+  })).every((flag) => flag) || _report(_exceptionable, {
+    path: _path + ".permissions",
+    expected: "Array<Permission>",
+    value: input.permissions
+  }), ("object" === typeof input._metadata && null !== input._metadata || _report(_exceptionable, {
+    path: _path + "._metadata",
+    expected: "__type",
+    value: input._metadata
+  })) && _vo6(input._metadata, _path + "._metadata", _exceptionable) || _report(_exceptionable, {
+    path: _path + "._metadata",
+    expected: "__type",
+    value: input._metadata
+  })].every((flag) => flag);
+  const _vo1 = (input, _path, _exceptionable = true) => ["clipboard" === input.name || _report(_exceptionable, {
+    path: _path + ".name",
+    expected: '"clipboard"',
+    value: input.name
+  }), "read" === input.access || "write" === input.access || _report(_exceptionable, {
+    path: _path + ".access",
+    expected: '("read" | "write")',
+    value: input.access
+  })].every((flag) => flag);
+  const _vo2 = (input, _path, _exceptionable = true) => ["geolocation" === input.name || _report(_exceptionable, {
+    path: _path + ".name",
+    expected: '"geolocation"',
+    value: input.name
+  }), "access" === input.access || _report(_exceptionable, {
+    path: _path + ".access",
+    expected: '"access"',
+    value: input.access
+  })].every((flag) => flag);
+  const _vo3 = (input, _path, _exceptionable = true) => ["contacts" === input.name || _report(_exceptionable, {
+    path: _path + ".name",
+    expected: '"contacts"',
+    value: input.name
+  }), "read" === input.access || "write" === input.access || _report(_exceptionable, {
+    path: _path + ".access",
+    expected: '("read" | "write")',
+    value: input.access
+  })].every((flag) => flag);
+  const _vo4 = (input, _path, _exceptionable = true) => ["photos" === input.name || _report(_exceptionable, {
+    path: _path + ".name",
+    expected: '"photos"',
+    value: input.name
+  }), "read" === input.access || "write" === input.access || _report(_exceptionable, {
+    path: _path + ".access",
+    expected: '("read" | "write")',
+    value: input.access
+  })].every((flag) => flag);
+  const _vo5 = (input, _path, _exceptionable = true) => ["camera" === input.name || _report(_exceptionable, {
+    path: _path + ".name",
+    expected: '"camera"',
+    value: input.name
+  }), "access" === input.access || _report(_exceptionable, {
+    path: _path + ".access",
+    expected: '"access"',
+    value: input.access
+  })].every((flag) => flag);
+  const _vo6 = (input, _path, _exceptionable = true) => [(Array.isArray(input.bundleFiles) || _report(_exceptionable, {
+    path: _path + ".bundleFiles",
+    expected: "Array<string>",
+    value: input.bundleFiles
+  })) && input.bundleFiles.map((elem, _index4) => "string" === typeof elem || _report(_exceptionable, {
+    path: _path + ".bundleFiles[" + _index4 + "]",
+    expected: "string",
+    value: elem
+  })).every((flag) => flag) || _report(_exceptionable, {
+    path: _path + ".bundleFiles",
+    expected: "Array<string>",
+    value: input.bundleFiles
+  }), "string" === typeof input.deploymentId && (__typia_transform__isFormatUuid._isFormatUuid(input.deploymentId) || _report(_exceptionable, {
+    path: _path + ".deploymentId",
+    expected: 'string & Format<"uuid">',
+    value: input.deploymentId
+  })) || _report(_exceptionable, {
+    path: _path + ".deploymentId",
+    expected: '(string & Format<"uuid">)',
+    value: input.deploymentId
+  })].every((flag) => flag);
+  const _vu0 = (input, _path, _exceptionable = true) => (() => {
+    if ("camera" === input.name)
+      return _vo5(input, _path, _exceptionable);
+    else if ("photos" === input.name)
+      return _vo4(input, _path, _exceptionable);
+    else if ("contacts" === input.name)
+      return _vo3(input, _path, _exceptionable);
+    else if ("geolocation" === input.name)
+      return _vo2(input, _path, _exceptionable);
+    else if ("clipboard" === input.name)
+      return _vo1(input, _path, _exceptionable);
+    else
+      return _report(_exceptionable, {
+        path: _path,
+        expected: "(CameraPermission | PhotosPermission | ContactsPermission | GeolocationPermission | ClipboardPermission)",
+        value: input
+      });
+  })();
+  const __is = (input) => "object" === typeof input && null !== input && _io0(input);
+  let errors;
+  let _report;
+  return (input) => {
+    if (false === __is(input)) {
+      errors = [];
+      _report = __typia_transform__validateReport._validateReport(errors);
+      ((input2, _path, _exceptionable = true) => ("object" === typeof input2 && null !== input2 || _report(true, {
+        path: _path + "",
+        expected: "AppManifest",
+        value: input2
+      })) && _vo0(input2, _path + "", true) || _report(true, {
+        path: _path + "",
+        expected: "AppManifest",
+        value: input2
+      }))(input, "$input", true);
+      const success = 0 === errors.length;
+      return success ? {
+        success,
+        data: input
+      } : {
+        success,
+        errors,
+        data: input
+      };
+    }
+    return {
+      success: true,
+      data: input
+    };
+  };
+})();
+
+// src/utils/createArtifact.ts
+async function validateZip(zipPath) {
+  const appJsonString = await readZipContent(zipPath, "app.json");
+  const appJson = JSON.parse(appJsonString);
+  const validated = validateAppManifest(appJson);
+  if (!validated.success) {
+    throw new Error("granite.config.ts \uAC12\uC774 \uC62C\uBC14\uB974\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4.");
+  }
+}
+async function createArtifact(options) {
+  const { bundleFiles, outfile, appJsonPath, reactNativeVersion } = options;
+  const namedBundleFiles = bundleFiles.map((bundle) => {
+    const originalName = path5.basename(bundle.path);
+    const extension = path5.extname(originalName);
+    const runtime = reactNativeVersion.replace(new RegExp(/\./g), "_");
+    return {
+      path: bundle.path,
+      // TODO: Use shared utils for sync file name specification with Lambda
+      name: `bundle.${bundle.platform}.${runtime}${extension === ".map" ? `.js.map` : extension}`
+    };
+  });
+  await updateAppJsonMetadata({
+    runtimeVersion: reactNativeVersion,
+    bundleFiles: namedBundleFiles.map(({ name }) => name),
+    deploymentId: options.deploymentId,
+    packageJson: options.packageJson
+  });
+  await compressToZip({
+    files: [{ path: appJsonPath, name: "app.json" }, ...namedBundleFiles, ...options.additionalFilesToZip ?? []],
+    outfile
+  });
+  await validateZip(outfile);
+  return outfile;
+}
+
+// src/plugins/artifact.ts
+function appsInTossCreateArtifact(deploymentId) {
+  const packageRoot = getPackageRoot3();
+  return {
+    name: "apps-in-toss:create-artifact",
+    build: {
+      order: "post",
+      handler: async ({ buildResults, appName, cwd }) => {
+        const buildFailed = buildResults.some(isBuildFailure);
+        if (buildFailed) {
+          throw new Error("\uBC88\uB4E4 \uBE4C\uB4DC \uC2E4\uD328");
+        }
+        log("\uC571 \uBE4C\uB4DC \uC911...");
+        const { dependencies, devDependencies } = await collectDependencyVersions(cwd);
+        const artifactOutfile = await createArtifact({
+          reactNativeVersion: REACT_NATIVE_VERSION,
+          deploymentId,
+          packageJson: { dependencies, devDependencies },
+          bundleFiles: buildResults.filter(isBuildSuccess).map(({ outfile, sourcemapOutfile, platform }) => [
+            {
+              path: outfile,
+              platform
+            },
+            {
+              path: sourcemapOutfile,
+              platform
+            }
+          ]).flat(),
+          outfile: path6.join(cwd, `${appName}.ait`),
+          appJsonPath: path6.join(packageRoot, ".granite", APP_MANIFEST_NAME)
+        });
+        if (!artifactOutfile) {
+          throw new Error("\uC544\uD2F0\uD329\uD2B8 \uC0DD\uC131\uC5D0 \uC2E4\uD328\uD588\uC5B4\uC694.");
+        }
+        const filename = path6.basename(artifactOutfile);
+        log(`\u2705 ${pc2.green(`${filename}`)} \uBE4C\uB4DC \uC644\uB8CC`);
+      }
+    }
+  };
+}
+
+// src/plugins/build.ts
+init_esm_shims();
+function appsInTossEsbuildConfig(envScript) {
+  return {
+    name: "apps-in-toss:esbuild-config",
+    config: {
+      esbuild: {
+        banner: {
+          js: envScript
+        }
+      }
+    }
+  };
+}
+function appsInTossMetroConfig(envScriptPath) {
+  return {
+    name: "apps-in-toss:metro-config",
+    config: {
+      metro: {
+        serializer: {
+          getPolyfills: () => [envScriptPath]
+        }
+      }
+    }
+  };
+}
+
+// src/plugins/compat.ts
+init_esm_shims();
+import fs5 from "fs";
+import path7 from "path";
+import { getLocalTempDirectoryPath, getPackageRoot as getPackageRoot4 } from "@granite-js/utils";
+var nativeModuleProxyContent = `
+(function () {
+  global.nativeModuleProxy = new Proxy(global.nativeModuleProxy, {
+    get: function (target, name) {
+      if (name === 'GraniteModule') {
+        return target['BedrockModule'] || target[name];
+      }
+
+      if (name === 'GraniteCoreModule') {
+        return target['BedrockCoreModule'] || target[name];
+      }
+
+      return target[name];
+    }
+  });
+
+  global.__nativeModuleProxyConfigured = true;
+})(
+  typeof globalThis !== 'undefined'
+    ? globalThis
+    : typeof global !== 'undefined'
+    ? global
+    : typeof window !== 'undefined'
+    ? window
+    : this
+);
+`;
+var reactNativeModuleProxyContent = `
+(function (global) {
+  if (global.__nativeModuleProxyConfigured) {
+    return;
+  }
+
+  function getCustomTurboModuleRegistry(registry) {
+    var remappedModules = {
+      'GraniteModule': 'BedrockModule',
+      'GraniteCoreModule': 'BedrockCoreModule',
+    };
+
+    return {
+      get: function (name) {
+        var mod;
+        var remappedName = remappedModules[name];
+
+        if (remappedName) {
+          mod = registry.get(remappedName);
+        }
+
+        return mod || registry.get(name);
+      },
+      getEnforcing: function (name) {
+        var mod;
+        var remappedName = remappedModules[name];
+
+        if (remappedName) {
+          mod = registry.get(remappedName);
+        }
+
+        return mod || registry.getEnforcing(name);
+      }
+    };
+  }
+
+  function createReactNativeProxy(reactNative) {
+    return new Proxy(reactNative, {
+      get: function (target, name) {
+        var origin = target[name];
+        return name === 'TurboModuleRegistry' ? getCustomTurboModuleRegistry(origin) : origin;
+      }
+    });
+  }
+
+  var reactNative;
+
+  if (typeof global.__MICRO_FRONTEND__ !== 'undefined') {
+    var mod = global.__MICRO_FRONTEND__.__SHARED__['react-native'];
+    reactNative = mod && mod.get();
+  }
+
+  if (reactNative == null && typeof __bedrock_require__ === 'function') {
+    reactNative = global.__bedrock_require__('react-native');
+  }
+
+  if (reactNative == null) {
+    throw new Error('cannot get react-native in the global registry');
+  }
+
+  global.__reactNativeProxy = createReactNativeProxy(reactNative);
+  global.__MICRO_FRONTEND__.__SHARED__['react-native'] = {
+    get: function () {
+      return global.__reactNativeProxy;
+    },
+    loaded: true,
+  };
+})(
+  typeof globalThis !== 'undefined'
+    ? globalThis
+    : typeof global !== 'undefined'
+    ? global
+    : typeof window !== 'undefined'
+    ? window
+    : this
+);
+`;
+function bedrockCompat({ isHost }) {
+  const metroPolyfillContent = path7.join(getLocalTempDirectoryPath(getPackageRoot4()), "metro-native-module-proxy.js");
+  fs5.writeFileSync(metroPolyfillContent, nativeModuleProxyContent);
+  return {
+    name: "bedrock-compat-plugin",
+    config: {
+      esbuild: {
+        banner: {
+          js: isHost ? nativeModuleProxyContent : reactNativeModuleProxyContent
+        }
+      },
+      metro: {
+        serializer: {
+          getPolyfills: () => [metroPolyfillContent]
+        }
+      }
+    }
+  };
+}
+
+// src/plugins/devServer.ts
+init_esm_shims();
+
+// src/utils/createServerPermissionsMiddleware.ts
+init_esm_shims();
+function createServerPermissionsMiddleware(permissions) {
+  const parsedPermissions = parsePermissions(permissions);
+  return (req, res, next) => {
+    if (req.method === "GET" && req.url === "/permissions") {
+      res.writeHead(200, {
+        "Content-Length": Buffer.byteLength(parsedPermissions),
+        "Content-Type": "text/plain"
+      }).end(parsedPermissions);
+      return;
+    }
+    next();
+  };
+}
+function parsePermissions(permissions) {
+  const permissionMap = /* @__PURE__ */ new Map();
+  for (const permission of permissions) {
+    const { name, access: access2 } = permission;
+    if (!permissionMap.has(name)) {
+      permissionMap.set(name, /* @__PURE__ */ new Set());
+    }
+    let accessValue = null;
+    switch (access2) {
+      case "read":
+        accessValue = "r";
+        break;
+      case "write":
+        accessValue = "w";
+        break;
+      case "access":
+        accessValue = "a";
+        break;
+      default:
+        accessValue = null;
+    }
+    if (!accessValue) {
+      continue;
+    }
+    permissionMap.get(name).add(accessValue);
+  }
+  return Array.from(permissionMap.entries()).map(([name, accesses]) => `${name}:${Array.from(accesses).sort().join("")}`).sort().join(",");
+}
+
+// src/plugins/devServer.ts
+function appsInTossDevServer(options) {
+  return {
+    name: "apps-in-toss:dev-server",
+    config: {
+      metro: {
+        middlewares: [createServerPermissionsMiddleware(options.permissions)]
+      }
+    }
+  };
+}
+
+// src/plugins/notice.ts
+init_esm_shims();
+
+// src/plugins/resolve.ts
+init_esm_shims();
+import Module from "module";
+function getRequire() {
+  return typeof __require === "function" ? __require : Module.createRequire(import.meta.url);
+}
+function requireMicroFrontendRuntime() {
+  const require2 = getRequire();
+  const runtimePath = require2.resolve("@granite-js/plugin-micro-frontend/runtime");
+  return {
+    name: "apps-in-toss-micro-frontend",
+    config: {
+      resolver: {
+        alias: [
+          {
+            from: "@granite-js/plugin-micro-frontend/runtime",
+            to: runtimePath
+          }
+        ]
+      }
+    }
+  };
+}
+
+// src/utils/generateDeploymentId.ts
+init_esm_shims();
+import { uuidv7 } from "uuidv7";
+function generateDeploymentId() {
+  return uuidv7();
+}
+
+// src/utils/setupRuntimeSetupScript.ts
+init_esm_shims();
+import fs6 from "node:fs";
+import path8 from "node:path";
+import { getPackageRoot as getPackageRoot5 } from "@granite-js/utils";
+import { transformSync } from "esbuild";
+function setupHostRuntimeSetupScript(metadata) {
+  const script = getRuntimeSetupScript(metadata, HOST_CONTEXT_IDENTIFIER);
+  const setupScriptPath = writeRuntimeSetupScript(script);
+  return { contents: script, path: setupScriptPath };
+}
+function getRuntimeSetupScript(metadata, identifier) {
+  const script = `
+  (function (global) {
+    ${getBedrockCompatScript()}
+    ${identifier === HOST_CONTEXT_IDENTIFIER ? "" : getMicroFrontendCompatScript()}
+    global.${identifier} = ${JSON.stringify(metadata)};
+  })(
+    typeof globalThis !== 'undefined'
+      ? globalThis
+      : typeof global !== 'undefined'
+      ? global
+      : typeof window !== 'undefined'
+      ? window
+      : this
+  );
+  `;
+  return transformSync(script, {
+    minify: true,
+    sourcemap: false,
+    banner: "// Runtime setup script"
+  }).code;
+}
+function writeRuntimeSetupScript(script) {
+  const packageRoot = getPackageRoot5();
+  const granitePath = path8.join(packageRoot, ".granite");
+  try {
+    fs6.accessSync(granitePath);
+  } catch {
+    fs6.mkdirSync(granitePath, { recursive: true });
+  }
+  const envFilePath = path8.join(granitePath, ".apps-in-toss.env.js");
+  fs6.writeFileSync(envFilePath, script, "utf-8");
+  return envFilePath;
+}
+function getBedrockCompatScript() {
+  return `
+  if (global.__bedrock_require__ == null) {
+    global.__bedrock_require__ = function (id) {
+      return global.__MICRO_FRONTEND__.__SHARED__[id].get();
+    };
+  }
+  `;
+}
+function getMicroFrontendCompatScript() {
+  return `
+  function getHostContainer() {
+    var microFrontendContext = global.__MICRO_FRONTEND__;
+    var microFrontendInstances = microFrontendContext == null ? [] : microFrontendContext.__INSTANCES__;
+    var sharedContainer = microFrontendInstances.find(function (instance) {
+      return instance.name === '${MICRO_FRONTEND_HOST_NAME}';
+    });
+    return sharedContainer;
+  }
+
+  if (getHostContainer() == null) {
+    var hostContainerShim = { name: '${MICRO_FRONTEND_HOST_NAME}', config: {} };
+    var sharedModuleProxy = new Proxy({}, {
+      get(target, prop) {
+        var mod;
+
+        try {
+          mod = target[prop] && target[prop].get();
+        } catch {}
+
+        try {
+          mod = mod || global.__bedrock_require__(prop);
+        } catch {}
+
+        if (mod == null) {
+          return;
+        }
+
+        return {
+          get: function () {
+            return mod;
+          },
+          loaded: true,
+        };
+      },
+      set(target, prop, value) {
+        target[prop] = value;
+        return true;
+      }
+    });
+
+    global.__MICRO_FRONTEND__ = {
+      __INSTANCES__: [hostContainerShim],
+      __SHARED__: sharedModuleProxy,
+    };
+    global.__MICRO_FRONTEND__.__INSTANCES__['${MICRO_FRONTEND_HOST_NAME}'] = 0;
+  }
+  `;
+}
+
+// src/appsInTossHost.ts
+var PERMISSIONS = [];
+function appsInTossHost(options) {
+  const deploymentId = generateDeploymentId();
+  const { contents, path: envFilePath } = setupHostRuntimeSetupScript({
+    deploymentId
+  });
+  return [
+    requireMicroFrontendRuntime(),
+    microFrontend({
+      name: MICRO_FRONTEND_HOST_NAME,
+      remote: {
+        host: options?.remote?.host ?? "localhost",
+        port: options?.remote?.port ?? 8082
+      },
+      shared: SHRED_PACKAGES.reduce(
+        (prev, curr) => ({ ...prev, [curr]: { eager: true } }),
+        {}
+      )
+    }),
+    appsInTossAppJson({ permissions: PERMISSIONS }),
+    appsInTossDevServer({ permissions: PERMISSIONS }),
+    appsInTossCreateArtifact(deploymentId),
+    appsInTossEsbuildConfig(contents),
+    appsInTossMetroConfig(envFilePath),
+    bedrockCompat({ isHost: true })
+  ];
+}
+export {
+  appsInTossHost
+};