@penvhq/launcher 0.9.4 → 0.10.0

package/dist/bin.js

@@ -5,7 +5,7 @@ import {
   httpFetcher,
   nodeSpawner,
   runLauncher
-} from "./chunk-Q27F7QYT.js";
+} from "./chunk-BNUZ52VN.js";
 
 // src/bin.ts
 function readLine() {

package/dist/{chunk-Q27F7QYT.js → chunk-BNUZ52VN.js}

@@ -164,6 +164,7 @@ function setProviderType(source, environment, type) {
 import {
   ENGINE_PACKAGE,
   EXTENSIONS_PATH,
+  LOCAL_EXTENSIONS_PATH,
   MANIFEST_PATH,
   OFFICIAL_SCOPE,
   PenvError
@@ -175,6 +176,9 @@ function addCommand(name, version, extra) {
   const spec = version === void 0 ? name : `${name}@${version}`;
   return `penv add ${spec}${extra === void 0 ? "" : ` ${extra}`}`;
 }
+function addCommandFor(name, local) {
+  return local ? `penv add ${LOCAL_FLAG} ${name}` : addCommand(name);
+}
 var NoProjectError = class extends PenvError {
   name = "NoProjectError";
   constructor(cwd) {
@@ -271,7 +275,58 @@ var AddFlagError = class extends PenvError {
     super(
       "PENV_ADD_FLAG",
       `\`penv add\` does not understand \`${flag}\``,
-      `Run \`penv add <package>\` with \`${TRUST_YOUNG_FLAG}\` or \`--registry <url>\` \u2014 those are the two it takes.`
+      `Run \`penv add <package>\` with \`${TRUST_YOUNG_FLAG}\`, \`--registry <url>\`, or \`${LOCAL_FLAG}\` \u2014 those are the three it takes.`
+    );
+  }
+};
+var LOCAL_FLAG = "--local";
+var AddLocalFlagError = class extends PenvError {
+  name = "AddLocalFlagError";
+  constructor(subject) {
+    super(
+      "PENV_ADD_LOCAL_FLAG",
+      `\`penv add ${LOCAL_FLAG}\` cannot take ${subject}`,
+      `${LOCAL_FLAG} adds the package this project already builds, so there is no release to name and nothing to pin. Publish it and run \`penv add <package>\` to pin one.`
+    );
+  }
+};
+var ExtensionNotImportableError = class extends PenvError {
+  name = "ExtensionNotImportableError";
+  constructor(name, entry, local) {
+    super(
+      "PENV_EXTENSION_NOT_IMPORTABLE",
+      entry === void 0 ? `${name} declares no entry point penv can import` : `${name} resolves to ${entry}, which penv cannot import`,
+      `penv imports a provider with no transform, so its entry has to be built JavaScript. Point the package's \`exports\` at its build output \u2014 \`dist/index.js\` \u2014 then run \`${addCommandFor(name, local)}\` again.`
+    );
+  }
+};
+var ExtensionUnloadableError = class extends PenvError {
+  name = "ExtensionUnloadableError";
+  constructor(name, entry, detail, local) {
+    super(
+      "PENV_EXTENSION_UNLOADABLE",
+      `${name} threw while penv imported ${entry}: ${detail}`,
+      `Build the package and install its dependencies, then run \`${addCommandFor(name, local)}\` again. penv adds a provider it has loaded once, or none.`
+    );
+  }
+};
+var LocalExtensionUnresolvedError = class extends PenvError {
+  name = "LocalExtensionUnresolvedError";
+  constructor(name, root) {
+    super(
+      "PENV_LOCAL_EXTENSION_UNRESOLVED",
+      `${name} does not resolve from ${root}`,
+      `${LOCAL_FLAG} records that penv should read this package out of the project, so the project has to have it \u2014 add it as a dependency of the root (a workspace link is one), then run this again.`
+    );
+  }
+};
+var AddLocalInCiError = class extends PenvError {
+  name = "AddLocalInCiError";
+  constructor(name) {
+    super(
+      "PENV_ADD_LOCAL_IN_CI",
+      `Adding ${name} writes ${LOCAL_EXTENSIONS_PATH}, and CI does not decide what a project develops`,
+      `Run \`penv add ${LOCAL_FLAG} ${name}\` from a terminal and commit what it writes.`
     );
   }
 };
@@ -474,14 +529,20 @@ function readExtensionPackage(dir) {
   try {
     parsed = JSON.parse(readFileSync(join(dir, "package.json"), "utf8"));
   } catch {
-    return { types: void 0, onboard: void 0 };
+    return { name: void 0, version: void 0, types: void 0, onboard: void 0 };
   }
   const penv = field(parsed, "penv");
-  return { types: text(field(penv, "types")), onboard: text(field(penv, "onboard")) };
+  return {
+    name: text(field(parsed, "name")),
+    version: text(field(parsed, "version")),
+    types: text(field(penv, "types")),
+    onboard: text(field(penv, "onboard"))
+  };
 }
 function header(subject) {
-  const provenance = subject.attested ? "npm records a provenance attestation for it" : "npm records no provenance attestation for it";
-  return `// Written by \`penv add ${subject.name}\`, and committed.
+  const local = subject.local === true;
+  const provenance = local ? "resolved from this project, not from a published release" : subject.attested ? "npm records a provenance attestation for it" : "npm records no provenance attestation for it";
+  return `// Written by \`penv add ${local ? "--local " : ""}${subject.name}\`, and committed.
 // ${subject.name} ${subject.version} \u2014 ${provenance}.
 //
 // Types only: this declares the shape of the provider's \`penv.config.ts\`
@@ -555,32 +616,10 @@ function writeDeclaration(options) {
 
 // src/home.ts
 import { readFileSync as readFileSync2 } from "fs";
-import { homedir } from "os";
-import { join as join2, resolve as resolve2, sep as sep2 } from "path";
-import { PenvError as PenvError2 } from "@penvhq/core";
-var PENV_HOME_VAR = "PENV_HOME";
+import { join as join2 } from "path";
 var HOME_META_FILE = "meta.json";
 var INTEGRITY_FILE = ".penv-integrity";
 var NPM_UPDATE_COMMAND = "npm install -g @penvhq/launcher";
-function penvHome(env) {
-  const declared = env[PENV_HOME_VAR];
-  if (declared !== void 0 && declared.trim() !== "") {
-    return resolve2(declared);
-  }
-  return join2(homedir(), ".penv");
-}
-function packageDir(home, kind, name, version) {
-  const bucket = resolve2(home, kind);
-  const dir = resolve2(bucket, ...name.split("/"), version);
-  if (!dir.startsWith(bucket + sep2)) {
-    throw new PenvError2(
-      "PENV_HOME_ESCAPE",
-      `\`${name}\` at \`${version}\` resolves to ${dir}, which is outside ${bucket}`,
-      "Name the package exactly as npm does, e.g. `@penvhq/provider-vault`."
-    );
-  }
-  return dir;
-}
 function launcherUpdateCommand(home) {
   let meta;
   try {
@@ -685,6 +724,7 @@ import {
   writeFileSync as writeFileSync2
 } from "fs";
 import { dirname as dirname2, join as join3 } from "path";
+import { packageDir } from "@penvhq/core";
 var DEFAULT_REGISTRY = "https://registry.npmjs.org";
 function tarballUrl(pin) {
   const registry = (pin.registry ?? DEFAULT_REGISTRY).replace(/\/+$/, "");
@@ -819,9 +859,22 @@ async function fetchRelease(query) {
 }
 
 // src/add.ts
-import { readFileSync as readFileSync4, writeFileSync as writeFileSync3 } from "fs";
-import { relative, sep as sep3 } from "path";
-import { findConfigFile, MANIFEST_PATH as MANIFEST_PATH2, OFFICIAL_SCOPE as OFFICIAL_SCOPE2, serializeManifest } from "@penvhq/core";
+import { mkdirSync as mkdirSync3, readFileSync as readFileSync4, writeFileSync as writeFileSync3 } from "fs";
+import { createRequire } from "module";
+import { dirname as dirname3, relative, resolve as resolve2, sep as sep2 } from "path";
+import { pathToFileURL } from "url";
+import {
+  findConfigFile,
+  isImportableEntry,
+  LOCAL_EXTENSIONS_PATH as LOCAL_EXTENSIONS_PATH2,
+  localExtensionsFile,
+  MANIFEST_PATH as MANIFEST_PATH2,
+  OFFICIAL_SCOPE as OFFICIAL_SCOPE2,
+  packageEntry,
+  parseLocalExtensions,
+  serializeLocalExtensions,
+  serializeManifest
+} from "@penvhq/core";
 
 // src/repair.ts
 import { parseManifest } from "@penvhq/core";
@@ -885,8 +938,13 @@ function parseRequest(argv) {
   let spec;
   let registry;
   let trustYoung = false;
+  let local = false;
   for (let index = 0; index < argv.length; index += 1) {
     const token = argv[index] ?? "";
+    if (token === LOCAL_FLAG) {
+      local = true;
+      continue;
+    }
     if (token === TRUST_YOUNG_FLAG) {
       trustYoung = true;
       continue;
@@ -915,7 +973,18 @@ function parseRequest(argv) {
   if (!PACKAGE_NAME.test(name) || version === "") {
     throw new AddPackageNameError(spec);
   }
-  return { name, version, registry, trustYoung };
+  if (local) {
+    if (version !== void 0) {
+      throw new AddLocalFlagError("a version");
+    }
+    if (registry !== void 0) {
+      throw new AddLocalFlagError(`\`${REGISTRY_FLAG}\``);
+    }
+    if (trustYoung) {
+      throw new AddLocalFlagError(`\`${TRUST_YOUNG_FLAG}\``);
+    }
+  }
+  return { name, version, registry, trustYoung, local };
 }
 function tierOf(request) {
   if (request.name.startsWith(OFFICIAL_SCOPE2)) {
@@ -1002,7 +1071,7 @@ async function offerConfigEdit(options, name) {
     io.out(line);
     return;
   }
-  const shown = relative(root, configFile).split(sep3).join("/");
+  const shown = relative(root, configFile).split(sep2).join("/");
   let current = readFileSync4(configFile, "utf8");
   const entries = readProviderEntries(current);
   if (entries === void 0 || entries.length === 0) {
@@ -1048,9 +1117,90 @@ async function offerOnboarding(io, name, onboard) {
   io.out(`Run \`${command}\` to finish setting ${name} up.`);
   return void 0;
 }
+function resolvePackageDir(name, root) {
+  const require2 = createRequire(resolve2(root, "noop.js"));
+  try {
+    return dirname3(require2.resolve(`${name}/package.json`));
+  } catch {
+    let dir;
+    try {
+      dir = dirname3(require2.resolve(name));
+    } catch {
+      return void 0;
+    }
+    for (let current = dir, parent = dirname3(dir); current !== parent; parent = dirname3(current)) {
+      if (readExtensionPackage(current).name === name) {
+        return current;
+      }
+      current = parent;
+    }
+    return void 0;
+  }
+}
+function resolveProjectEntry(name, root) {
+  let file;
+  try {
+    file = createRequire(resolve2(root, "noop.js")).resolve(name);
+  } catch {
+    return void 0;
+  }
+  return { file, importable: isImportableEntry(file) };
+}
+async function assertLoadable(name, entry, local) {
+  if (entry === void 0 || !entry.importable) {
+    throw new ExtensionNotImportableError(name, entry?.file, local);
+  }
+  try {
+    await import(pathToFileURL(entry.file).href);
+  } catch (cause) {
+    const detail = cause instanceof Error ? cause.message : String(cause);
+    throw new ExtensionUnloadableError(name, entry.file, detail, local);
+  }
+}
+function recordLocalExtension(root, name) {
+  const file = localExtensionsFile(root);
+  let current;
+  try {
+    current = readFileSync4(file, "utf8");
+  } catch {
+    current = "[]";
+  }
+  mkdirSync3(dirname3(file), { recursive: true });
+  writeFileSync3(file, serializeLocalExtensions([...parseLocalExtensions(current), name]));
+}
+async function addLocal(options, request) {
+  const { io, root } = options;
+  if (options.ci === true) {
+    throw new AddLocalInCiError(request.name);
+  }
+  const dir = resolvePackageDir(request.name, root);
+  if (dir === void 0) {
+    throw new LocalExtensionUnresolvedError(request.name, root);
+  }
+  await assertLoadable(request.name, resolveProjectEntry(request.name, root), true);
+  const installed = readExtensionPackage(dir);
+  const declaration = writeDeclaration({
+    root,
+    dir,
+    name: request.name,
+    version: installed.version ?? "unpublished",
+    attested: false,
+    local: true,
+    types: installed.types
+  });
+  recordLocalExtension(root, request.name);
+  io.out(`\u2713 ${request.name} resolves from this project and imports \u2014 nothing is pinned`);
+  io.out(`\u2713 ${LOCAL_EXTENSIONS_PATH2} records it`);
+  io.out(`\u2713 ${declaration} declares its config type`);
+  await offerConfigEdit(options, request.name);
+  return { onboard: await offerOnboarding(io, request.name, installed.onboard) };
+}
 async function add(options) {
   const { io, fetcher, home, root, manifestFile } = options;
   const request = parseRequest(options.argv);
+  if (request.local) {
+    return addLocal(options, request);
+  }
   const tier = tierOf(request);
   const now = (options.now ?? (() => /* @__PURE__ */ new Date()))();
   if (options.noDownload === true) {
@@ -1084,6 +1234,7 @@ async function add(options) {
     },
     fetcher
   });
+  await assertLoadable(release.name, packageEntry(dir), false);
   const installed = readExtensionPackage(dir);
   const declaration = writeDeclaration({
     root,
@@ -1147,13 +1298,13 @@ function nodeSpawner() {
 
 // src/engine.ts
 import { existsSync as existsSync2, readFileSync as readFileSync5 } from "fs";
-import { createRequire } from "module";
-import { dirname as dirname3, join as join4, resolve as resolve3, sep as sep4 } from "path";
-import { ENGINE_PACKAGE as ENGINE_PACKAGE2, PenvError as PenvError3 } from "@penvhq/core";
+import { createRequire as createRequire2 } from "module";
+import { dirname as dirname4, join as join5, resolve as resolve3, sep as sep3 } from "path";
+import { ENGINE_PACKAGE as ENGINE_PACKAGE2, PenvError as PenvError2 } from "@penvhq/core";
 var ENGINE_BIN = "penv-engine";
 function readPackageManifest(dir) {
   try {
-    return JSON.parse(readFileSync5(join4(dir, "package.json"), "utf8"));
+    return JSON.parse(readFileSync5(join5(dir, "package.json"), "utf8"));
   } catch {
     return void 0;
   }
@@ -1177,24 +1328,24 @@ function engineAt(dir, name, version) {
   const bin = manifest === void 0 ? void 0 : binPath(manifest.bin);
   const root = resolve3(dir);
   const entry = bin === void 0 ? void 0 : resolve3(root, bin);
-  if (entry === void 0 || !entry.startsWith(root + sep4) || !existsSync2(entry)) {
+  if (entry === void 0 || !entry.startsWith(root + sep3) || !existsSync2(entry)) {
     throw new EngineEntryError(name, version, dir);
   }
   return { name, version, dir, entry };
 }
 function bundledEngine() {
-  const require2 = createRequire(import.meta.url);
+  const require2 = createRequire2(import.meta.url);
   let manifestFile;
   try {
     manifestFile = require2.resolve(`${ENGINE_PACKAGE2}/package.json`);
   } catch {
-    throw new PenvError3(
+    throw new PenvError2(
       "PENV_NO_BUNDLED_ENGINE",
       `This penv installation is missing ${ENGINE_PACKAGE2}, the engine it runs \`init\` with`,
       "Reinstall the launcher with `npm install -g @penvhq/launcher`."
     );
   }
-  const dir = dirname3(manifestFile);
+  const dir = dirname4(manifestFile);
   const version = readPackageManifest(dir)?.version;
   return engineAt(dir, ENGINE_PACKAGE2, typeof version === "string" ? version : "unknown");
 }
@@ -1218,8 +1369,8 @@ var DEV_PIN_INTEGRITY = "sha512-development-build-not-a-published-release";
 var DEV_PIN_VERSION = "0.0.0-dev";
 var BUNDLED_ENGINE_PIN = {
   package: ENGINE_PACKAGE3,
-  version: "0.9.4",
-  integrity: "sha512-XnG+KlEAZyUaaKUfANPiyhY1dfYZ9KgnkF2R+5A0OskRgfYPSpBRN0i1UPtq8RnwMJaPxfSNDNdqfiiESz6kRw=="
+  version: "0.10.0",
+  integrity: "sha512-b+U0c3xWbk1ILtMfPjJW8x5XBxSLAaw/IAOLMBmGvT2uuYv41JPED8PrenEj4s3ZJY5BxpWU9mQcJHEBouaw/Q=="
 };
 function assertReleasePin(pin) {
   if (pin.integrity === DEV_PIN_INTEGRITY || pin.version === DEV_PIN_VERSION) {
@@ -1236,7 +1387,7 @@ function releaseEnginePin(pin, ranVersion) {
 
 // src/project.ts
 import { existsSync as existsSync3 } from "fs";
-import { dirname as dirname4, join as join5, resolve as resolve4 } from "path";
+import { dirname as dirname5, join as join6, resolve as resolve4 } from "path";
 import { MANIFEST_PATH as MANIFEST_PATH3, stateDir } from "@penvhq/core";
 var MANIFEST_SEGMENTS = MANIFEST_PATH3.split("/");
 function findUp(cwd, matches) {
@@ -1245,7 +1396,7 @@ function findUp(cwd, matches) {
     if (matches(dir)) {
       return dir;
     }
-    const parent = dirname4(dir);
+    const parent = dirname5(dir);
     if (parent === dir) {
       return void 0;
     }
@@ -1253,8 +1404,8 @@ function findUp(cwd, matches) {
   }
 }
 function findProject(cwd) {
-  const root = findUp(cwd, (dir) => existsSync3(join5(dir, ...MANIFEST_SEGMENTS)));
-  return root === void 0 ? void 0 : { root, manifestFile: join5(root, ...MANIFEST_SEGMENTS) };
+  const root = findUp(cwd, (dir) => existsSync3(join6(dir, ...MANIFEST_SEGMENTS)));
+  return root === void 0 ? void 0 : { root, manifestFile: join6(root, ...MANIFEST_SEGMENTS) };
 }
 function findAdoptedRoot(cwd) {
   return findUp(cwd, (dir) => existsSync3(stateDir(dir)));
@@ -1262,15 +1413,51 @@ function findAdoptedRoot(cwd) {
 
 // src/launcher.ts
 import { existsSync as existsSync4, readFileSync as readFileSync6, writeFileSync as writeFileSync4 } from "fs";
-import { join as join6 } from "path";
+import { join as join7 } from "path";
 import {
   MANIFEST_FORMAT,
-  MANIFEST_PATH as MANIFEST_PATH4,
-  PenvError as PenvError4,
+  MANIFEST_PATH as MANIFEST_PATH5,
+  PENV_HOME_VAR,
+  PenvError as PenvError3,
   parseManifest as parseManifest2,
+  penvHome,
   serializeManifest as serializeManifest2,
   UnsupportedManifestFormatError
 } from "@penvhq/core";
+
+// src/help.ts
+import { EXTENSIONS_PATH as EXTENSIONS_PATH3, MANIFEST_PATH as MANIFEST_PATH4 } from "@penvhq/core";
+function printLauncherCommands(io) {
+  io.out("");
+  io.out("LAUNCHER COMMANDS (penv itself, whatever engine a project pins)");
+  io.out("");
+  io.out(`  install                Installs everything ${MANIFEST_PATH4} pins`);
+  io.out("  add <package>          Pins a provider extension, and commits the decision");
+  io.out(`  add ${LOCAL_FLAG} <package>  Adds the one this repository builds \u2014 nothing is pinned`);
+  io.out("");
+}
+function printInstallHelp(io) {
+  io.out(`${INSTALL_COMMAND}`);
+  io.out("");
+  io.out(`Downloads, verifies and installs every version ${MANIFEST_PATH4} pins \u2014 the engine and`);
+  io.out("every extension \u2014 into $PENV_HOME. The one penv command CI and production run that");
+  io.out("may reach the registry.");
+}
+function printAddHelp(io) {
+  io.out("penv add <package>[@<version>]");
+  io.out("");
+  io.out(`  ${LOCAL_FLAG}            Add the package this repository builds, resolved from it`);
+  io.out("  --registry <url>   Take the release from a private registry instead of npmjs");
+  io.out(
+    `  ${TRUST_YOUNG_FLAG}      Add a release published less than ${MIN_PACKAGE_AGE_DAYS} days ago`
+  );
+  io.out("");
+  io.out(`Pins the release in ${MANIFEST_PATH4} and writes its type declaration to`);
+  io.out(`${EXTENSIONS_PATH3}/. Both are committed, so \`${INSTALL_COMMAND}\` gives every machine`);
+  io.out(`the bytes you reviewed. \`${LOCAL_FLAG}\` pins nothing and touches no manifest.`);
+}
+
+// src/launcher.ts
 var INSTALL = "install";
 var ADD = "add";
 var VERSION_FLAGS = /* @__PURE__ */ new Set(["--version", "-v"]);
@@ -1336,7 +1523,7 @@ function readManifestToRepair(manifestFile, home, argv) {
   }
 }
 function report(error, io) {
-  if (error instanceof PenvError4 && error.remedy !== void 0) {
+  if (error instanceof PenvError3 && error.remedy !== void 0) {
     const suffix = `
   ${error.remedy}`;
     const message = error.message.endsWith(suffix) ? error.message.slice(0, -suffix.length) : error.message;
@@ -1359,6 +1546,16 @@ async function launch(options) {
   const { noDownload, forwarded } = splitLauncherFlags(argv);
   const first = forwarded[0];
   const home = penvHome(env);
+  if (first !== void 0 && forwarded.slice(1).some((token) => HELP_FLAGS.has(token))) {
+    if (first === INSTALL) {
+      printInstallHelp(io);
+      return 0;
+    }
+    if (first === ADD) {
+      printAddHelp(io);
+      return 0;
+    }
+  }
   const project = findProject(cwd);
   if (project === void 0) {
     if (first !== void 0 && VERSION_FLAGS.has(first)) {
@@ -1403,7 +1600,7 @@ async function adopt(options, forwarded, home, cwd, noDownload) {
   if (root === void 0) {
     return 0;
   }
-  const manifestFile = join6(root, ...MANIFEST_PATH4.split("/"));
+  const manifestFile = join7(root, ...MANIFEST_PATH5.split("/"));
   if (existsSync4(manifestFile)) {
     return 0;
   }
@@ -1412,7 +1609,7 @@ async function adopt(options, forwarded, home, cwd, noDownload) {
     manifestFile,
     serializeManifest2({ format: MANIFEST_FORMAT, engine: pin, extensions: {} })
   );
-  options.io.out(`\u2713 ${MANIFEST_PATH4} pins ${pin.package} ${pin.version}`);
+  options.io.out(`\u2713 ${MANIFEST_PATH5} pins ${pin.package} ${pin.version}`);
   await ensureAdoptedEngine(
     options,
     { name: pin.package, version: pin.version, integrity: pin.integrity },
@@ -1491,13 +1688,21 @@ async function addExtension(options, project, home, argv, noDownload) {
   const engine = engineAt(dir, enginePin.name, enginePin.version);
   return delegate(options, engine, onboard, home, options.cwd);
 }
-function delegate(options, engine, forwarded, home, cwd) {
-  return options.spawn({
+function isRootHelp(forwarded) {
+  const first = forwarded[0];
+  return first === void 0 || HELP_FLAGS.has(first);
+}
+async function delegate(options, engine, forwarded, home, cwd) {
+  const code = await options.spawn({
     command: process.execPath,
     args: [engine.entry, ...forwarded],
     cwd,
     env: { ...options.env, [PENV_HOME_VAR]: home }
   });
+  if (code === 0 && isRootHelp(forwarded)) {
+    printLauncherCommands(options.io);
+  }
+  return code;
 }
 
 export {
@@ -1516,6 +1721,12 @@ export {
   AddSubjectError,
   AddPackageNameError,
   AddFlagError,
+  LOCAL_FLAG,
+  AddLocalFlagError,
+  ExtensionNotImportableError,
+  ExtensionUnloadableError,
+  LocalExtensionUnresolvedError,
+  AddLocalInCiError,
   AddRegistryError,
   OfficialRegistryError,
   RegistryUnreadableError,
@@ -1537,12 +1748,9 @@ export {
   renderDeclaration,
   declarationPath,
   writeDeclaration,
-  PENV_HOME_VAR,
   HOME_META_FILE,
   INTEGRITY_FILE,
   NPM_UPDATE_COMMAND,
-  penvHome,
-  packageDir,
   launcherUpdateCommand,
   integrityOf,
   readTarball,
@@ -1567,4 +1775,4 @@ export {
   findAdoptedRoot,
   runLauncher
 };
-//# sourceMappingURL=chunk-Q27F7QYT.js.map
+//# sourceMappingURL=chunk-BNUZ52VN.js.map