@uipath/packager-tool-webapp 1.204.0-preview.254 → 1.205.0-preview.256

package/dist/action-schema/index.js

@@ -385,13 +385,57 @@ import {
 
 // src/webapp-tool.ts
 import {
-  Path as Path5,
+  Path as Path6,
   ProjectTool as ProjectTool2,
   TemporaryStorageService,
   ToolErrorCodes,
   ToolResult
 } from "@uipath/solutionpackager-tool-core";
 
+// src/utils/bundle-path.ts
+import { Path } from "@uipath/solutionpackager-tool-core";
+function normalizeBundlePath(path) {
+  return path.replace(/\\/g, "/");
+}
+function isBundleRelativePath(path) {
+  const normalized = normalizeBundlePath(path);
+  const segments = normalized.split("/");
+  return !normalized.startsWith("/") && !/^[a-zA-Z]:/.test(normalized) && !segments.includes("..") && segments.some((segment) => segment !== "" && segment !== ".");
+}
+async function isCanonicalBundleChild(fileSystem, projectPath, bundlePath) {
+  const project = normalizeBundlePath(await fileSystem.realpath(projectPath)).replace(/\/+$/, "") || "/";
+  let bundle = project;
+  for (const segment of normalizeBundlePath(bundlePath).split("/")) {
+    if (!segment || segment === ".")
+      continue;
+    bundle = normalizeBundlePath(await fileSystem.realpath(Path.join(bundle, segment))).replace(/\/+$/, "") || "/";
+  }
+  return bundle !== project && bundle.startsWith(project === "/" ? "/" : `${project}/`);
+}
+function isHtmlEntryPointPath(path) {
+  return typeof path === "string" && isBundleRelativePath(path) && /\.html?$/i.test(path);
+}
+async function resolveHtmlEntryPoint(fileSystem, folder, declaredPath) {
+  if (!isHtmlEntryPointPath(declaredPath))
+    return null;
+  const segments = normalizeBundlePath(declaredPath).split("/").filter((part) => part !== "" && part !== ".");
+  if (!(await fileSystem.stat(Path.join(folder, ...segments)))?.isFile())
+    return null;
+  const actual = [];
+  for (const segment of segments) {
+    const entries = await fileSystem.readdir(Path.join(folder, ...actual));
+    if (entries.includes(segment)) {
+      actual.push(segment);
+      continue;
+    }
+    const matches = entries.filter((entry) => entry.toLowerCase() === segment.toLowerCase());
+    if (matches.length !== 1)
+      return null;
+    actual.push(matches[0]);
+  }
+  return actual.join("/");
+}
+
 // src/constants.ts
 var PROJECT_JSON_FILE = "project.json";
 var DEFAULT_BUNDLE_PATH = "source/dist";
@@ -400,12 +444,23 @@ var CONTENT_APP_FOLDER_NAME = "app";
 var TARGET_RUNTIME = "Coded";
 var TARGET_JS_RUNTIME = "JS";
 var DEFAULT_ENTRY_POINT_TYPE = "api";
+var HTML_ENTRY_POINT_CANDIDATES = [
+  "index.html",
+  "main.html",
+  "app.html"
+];
 var ERROR_MESSAGES = {
   MANIFEST_NOT_FOUND: (file) => `WebApp manifest not found: ${file}. This file is required for WebApp projects.`,
   PROJECT_JSON_FOUND: "project.json found in WebApp project. The WebApp tool only supports Coded web apps without project.json.",
   MANIFEST_LOAD_FAILED: (file) => `Failed to load or parse ${file}`,
   BUNDLE_NOT_FOUND: (path) => `Compiled bundle not found at ${path}. Ensure the project is built before packing.`,
   BUNDLE_NOT_DIRECTORY: (path) => `Bundle path ${path} exists but is not a directory.`,
+  BUNDLE_OUTSIDE_PROJECT: (path) => `Bundle path ${path} resolves to the project root or outside the project. Use a child build output folder inside the project.`,
+  BUNDLE_NO_ENTRY_POINT: (path) => `Bundle at ${path} has no HTML entry point (${HTML_ENTRY_POINT_CANDIDATES.join(", ")}). Build the app before packing, or point config.bundlePath in webAppManifest.json at its build output.`,
+  MAIN_FILE_INVALID_TYPE: "Invalid webAppManifest.json: config.mainFile must be a string naming an HTML file, or be omitted.",
+  MAIN_FILE_NOT_IN_BUNDLE: (path, mainFile) => `${WEBAPP_MANIFEST_FILE_NAME} asks for "${mainFile}" as the app's main file, but the bundle at ${path} does not hold it. Name an HTML file inside the bundle in config.mainFile, or remove it to use the first of ${HTML_ENTRY_POINT_CANDIDATES.join(", ")} the bundle holds.`,
+  MAIN_FILE_LOST: (path, mainFile) => `Bundle at ${path} held "${mainFile}" when the pack started, but the copy taken for the package has not. Something changed the folder mid-pack — usually a build or watch process. Stop it and pack again.`,
+  BUNDLE_ENTRY_POINT_LOST: (path) => `Bundle at ${path} had an HTML entry point (${HTML_ENTRY_POINT_CANDIDATES.join(", ")}) when the pack started, but the copy taken for the package has none. Something changed the folder mid-pack — usually a build or watch process. Stop it and pack again.`,
   APP_FOLDER_NOT_FOUND: (path) => `.app folder not found at ${path}. Ensure the project contains a .app folder.`,
   APP_FOLDER_NOT_DIRECTORY: (path) => `.app path ${path} exists but is not a directory.`,
   BUILD_NOT_SUPPORTED: "Build execution (isCompiled=false) is not yet supported. Please build the project manually and set isCompiled=true.",
@@ -421,19 +476,19 @@ var ERROR_MESSAGES = {
 import {
   NugetConstants,
   NugetPackager,
-  Path as Path3,
+  Path as Path4,
   ProjectTypes,
   TargetFramework
 } from "@uipath/solutionpackager-tool-core";
 
 // src/utils/fs-helpers.ts
-import { Path } from "@uipath/solutionpackager-tool-core";
+import { Path as Path2 } from "@uipath/solutionpackager-tool-core";
 async function copyDirectoryAsync(fileSystem, sourcePath, destinationPath) {
   await fileSystem.mkdir(destinationPath);
   const entries = await fileSystem.readdir(sourcePath);
   for (const entry of entries) {
-    const sourceEntry = Path.join(sourcePath, entry);
-    const destEntry = Path.join(destinationPath, entry);
+    const sourceEntry = Path2.join(sourcePath, entry);
+    const destEntry = Path2.join(destinationPath, entry);
     const stat = await fileSystem.stat(sourceEntry);
     if (stat?.isDirectory()) {
       await copyDirectoryAsync(fileSystem, sourceEntry, destEntry);
@@ -447,9 +502,9 @@ async function copyDirectoryAsync(fileSystem, sourcePath, destinationPath) {
 }
 
 // src/utils/manifest-loader.ts
-import { Path as Path2 } from "@uipath/solutionpackager-tool-core";
+import { Path as Path3 } from "@uipath/solutionpackager-tool-core";
 async function loadWebAppManifest2(fileSystem, projectPath) {
-  const manifestPath = Path2.join(projectPath, WEBAPP_MANIFEST_FILE_NAME);
+  const manifestPath = Path3.join(projectPath, WEBAPP_MANIFEST_FILE_NAME);
   const exists = await fileSystem.exists(manifestPath);
   if (!exists) {
     return null;
@@ -474,7 +529,7 @@ async function ensureWebAppProjectId(fileSystem, projectPath) {
   const id = crypto.randomUUID();
   if (manifest) {
     const updated = { ...manifest, projectId: id };
-    const manifestPath = Path2.join(projectPath, WEBAPP_MANIFEST_FILE_NAME);
+    const manifestPath = Path3.join(projectPath, WEBAPP_MANIFEST_FILE_NAME);
     await fileSystem.writeFile(manifestPath, `${JSON.stringify(updated, null, 2)}
 `);
   }
@@ -496,10 +551,9 @@ class CodedAppStrategy {
     }
     const isCompiled = typed.config?.isCompiled ?? true;
     if (isCompiled) {
-      const fullBundlePath = Path3.join(projectPath, bundlePath);
-      const exists = await this.fileSystem.exists(fullBundlePath);
-      if (!exists) {
-        const message = ERROR_MESSAGES.BUNDLE_NOT_FOUND(fullBundlePath);
+      const fullBundlePath = Path4.join(projectPath, bundlePath);
+      const message = await this.describeBundleProblemAsync(fullBundlePath, typed.config?.mainFile);
+      if (message) {
         const warnable = logger;
         if (warnable?.warn) {
           warnable.warn(message);
@@ -517,7 +571,11 @@ class CodedAppStrategy {
       bundlePath = DEFAULT_BUNDLE_PATH;
     }
     const isCompiled = manifest.config?.isCompiled ?? true;
-    const fullBundlePath = Path3.join(projectPath, bundlePath);
+    const declaredMainFile = manifest.config?.mainFile;
+    const fullBundlePath = Path4.join(projectPath, bundlePath);
+    if (isBundleRelativePath(bundlePath) && !await isCanonicalBundleChild(this.fileSystem, projectPath, bundlePath)) {
+      throw new Error(ERROR_MESSAGES.BUNDLE_OUTSIDE_PROJECT(bundlePath));
+    }
     if (isCompiled) {
       logger?.progress("Validating compiled bundle...");
       const bundleExists = await this.fileSystem.exists(fullBundlePath);
@@ -528,21 +586,25 @@ class CodedAppStrategy {
       if (!bundleStat?.isDirectory()) {
         throw new Error(ERROR_MESSAGES.BUNDLE_NOT_DIRECTORY(fullBundlePath));
       }
+      const problem = await this.describeBundleEntryProblemAsync(fullBundlePath, declaredMainFile);
+      if (problem) {
+        throw new Error(problem);
+      }
     } else {
       logger?.info("Build mode (isCompiled=false) is not yet implemented in v1.");
       throw new Error(ERROR_MESSAGES.BUILD_NOT_SUPPORTED);
     }
-    const localBuildFolder = Path3.join(outputPath, NugetConstants.OutputFolderName);
-    const contentFolder = Path3.join(localBuildFolder, NugetConstants.ContentFolderName);
-    await this.fileSystem.mkdir(contentFolder);
+    const localBuildFolder = Path4.join(outputPath, `${NugetConstants.OutputFolderName}-${crypto.randomUUID()}`);
+    const contentFolder = Path4.join(localBuildFolder, NugetConstants.ContentFolderName);
     try {
+      await this.fileSystem.mkdir(contentFolder);
       logger?.progress("Copying bundle to content folder...");
       await copyDirectoryAsync(this.fileSystem, fullBundlePath, contentFolder);
       logger?.progress("Preparing metadata files...");
-      await this.prepareMetadataFiles(localBuildFolder, contentFolder, packageInfo, manifest, projectPath);
+      await this.prepareMetadataFiles(localBuildFolder, contentFolder, packageInfo, manifest, projectPath, fullBundlePath);
       logger?.progress("Creating NuGet package...");
       const nupkgFileName = `${packageInfo.id}.${packageInfo.version}.nupkg`;
-      const nupkgPath = Path3.join(outputPath, nupkgFileName);
+      const nupkgPath = Path4.join(outputPath, nupkgFileName);
       const packager = new NugetPackager(this.fileSystem);
       const result = await packager.packAsync(localBuildFolder, packageInfo, nupkgPath);
       logger?.info(`Package created successfully: ${result.outputPath}`);
@@ -555,21 +617,13 @@ class CodedAppStrategy {
       }
     }
   }
-  async prepareMetadataFiles(_localBuildFolder, contentFolder, _packageInfo, _manifest, projectPath) {
-    let mainFile = "index.html";
-    const indexHtmlPath = Path3.join(contentFolder, "index.html");
-    const indexHtmlExists = await this.fileSystem.exists(indexHtmlPath);
-    if (!indexHtmlExists) {
-      const possibleEntries = ["index.html", "main.html", "app.html"];
-      for (const entry of possibleEntries) {
-        const entryPath = Path3.join(contentFolder, entry);
-        if (await this.fileSystem.exists(entryPath)) {
-          mainFile = entry;
-          break;
-        }
-      }
+  async prepareMetadataFiles(_localBuildFolder, contentFolder, _packageInfo, manifest, projectPath, sourceBundlePath) {
+    const declaredMainFile = manifest.config?.mainFile;
+    const mainFile = await this.resolveMainFileAsync(contentFolder, declaredMainFile);
+    if (!mainFile) {
+      throw new Error(declaredMainFile ? ERROR_MESSAGES.MAIN_FILE_LOST(sourceBundlePath, declaredMainFile) : ERROR_MESSAGES.BUNDLE_ENTRY_POINT_LOST(sourceBundlePath));
     }
-    const operatePath = Path3.join(contentFolder, NugetConstants.OperateFileName);
+    const operatePath = Path4.join(contentFolder, NugetConstants.OperateFileName);
     const operateModel = {
       projectId: await ensureWebAppProjectId(this.fileSystem, projectPath),
       main: mainFile,
@@ -583,17 +637,13 @@ class CodedAppStrategy {
     };
     const operateJson = JSON.stringify(operateModel, null, 2);
     await this.fileSystem.writeFile(operatePath, operateJson);
-    const manifestSourcePath = Path3.join(projectPath, WEBAPP_MANIFEST_FILE_NAME);
-    const manifestDestPath = Path3.join(contentFolder, WEBAPP_MANIFEST_FILE_NAME);
-    const manifestExists = await this.fileSystem.exists(manifestSourcePath);
-    if (manifestExists) {
-      const manifestContent = await this.fileSystem.readFile(manifestSourcePath, "utf-8");
-      if (manifestContent) {
-        await this.fileSystem.writeFile(manifestDestPath, manifestContent);
-      }
-    }
-    const uipathJsonSourcePath = Path3.join(projectPath, "uipath.json");
-    const uipathJsonDestPath = Path3.join(contentFolder, "uipath.json");
+    await this.fileSystem.writeFile(Path4.join(contentFolder, WEBAPP_MANIFEST_FILE_NAME), JSON.stringify({
+      ...manifest,
+      config: { ...manifest.config, mainFile },
+      projectId: operateModel.projectId
+    }, null, 2));
+    const uipathJsonSourcePath = Path4.join(projectPath, "uipath.json");
+    const uipathJsonDestPath = Path4.join(contentFolder, "uipath.json");
     const uipathJsonExists = await this.fileSystem.exists(uipathJsonSourcePath);
     if (uipathJsonExists) {
       const uipathJsonContent = await this.fileSystem.readFile(uipathJsonSourcePath, "utf-8");
@@ -601,8 +651,8 @@ class CodedAppStrategy {
         await this.fileSystem.writeFile(uipathJsonDestPath, uipathJsonContent);
       }
     }
-    const actionSchemaSourcePath = Path3.join(projectPath, "action-schema.json");
-    const actionSchemaDestPath = Path3.join(contentFolder, "action-schema.json");
+    const actionSchemaSourcePath = Path4.join(projectPath, "action-schema.json");
+    const actionSchemaDestPath = Path4.join(contentFolder, "action-schema.json");
     const actionSchemaExists = await this.fileSystem.exists(actionSchemaSourcePath);
     if (actionSchemaExists) {
       const actionSchemaContent = await this.fileSystem.readFile(actionSchemaSourcePath, "utf-8");
@@ -610,7 +660,7 @@ class CodedAppStrategy {
         await this.fileSystem.writeFile(actionSchemaDestPath, actionSchemaContent);
       }
     }
-    const bindingsPath = Path3.join(contentFolder, "bindings.json");
+    const bindingsPath = Path4.join(contentFolder, "bindings.json");
     const bindingsExists = await this.fileSystem.exists(bindingsPath);
     if (!bindingsExists) {
       const bindingsJson = JSON.stringify({
@@ -619,12 +669,12 @@ class CodedAppStrategy {
       }, null, 2);
       await this.fileSystem.writeFile(bindingsPath, bindingsJson);
     }
-    const bindingsV2Path = Path3.join(contentFolder, "bindings_v2.json");
+    const bindingsV2Path = Path4.join(contentFolder, "bindings_v2.json");
     const bindingsCandidatePaths = [
-      Path3.join(projectPath, "source", "bindings_v2.json"),
-      Path3.join(projectPath, "source", "bindings.json"),
-      Path3.join(projectPath, "bindings.json"),
-      Path3.join(projectPath, "bindings_v2.json")
+      Path4.join(projectPath, "source", "bindings_v2.json"),
+      Path4.join(projectPath, "source", "bindings.json"),
+      Path4.join(projectPath, "bindings.json"),
+      Path4.join(projectPath, "bindings_v2.json")
     ];
     let bindingsV2Json = null;
     for (const candidate of bindingsCandidatePaths) {
@@ -644,14 +694,14 @@ class CodedAppStrategy {
       }, null, 2);
     }
     await this.fileSystem.writeFile(bindingsV2Path, bindingsV2Json);
-    const entryPointsPath = Path3.join(contentFolder, "entry-points.json");
-    const projectEntryPointsPath = Path3.join(projectPath, "entry-points.json");
+    const entryPointsPath = Path4.join(contentFolder, "entry-points.json");
+    const projectEntryPointsPath = Path4.join(projectPath, "entry-points.json");
     let entryPointsContent;
     const projectEntryPointsExists = await this.fileSystem.exists(projectEntryPointsPath);
     if (projectEntryPointsExists) {
       const entryPointsData = await this.fileSystem.readFile(projectEntryPointsPath, "utf-8");
       if (entryPointsData) {
-        entryPointsContent = entryPointsData;
+        entryPointsContent = this.alignEntryPoint(entryPointsData, mainFile);
       } else {
         entryPointsContent = this.createDefaultEntryPoints(mainFile);
       }
@@ -659,18 +709,68 @@ class CodedAppStrategy {
       entryPointsContent = this.createDefaultEntryPoints(mainFile);
     }
     await this.fileSystem.writeFile(entryPointsPath, entryPointsContent);
-    const packageDescriptorPath = Path3.join(contentFolder, NugetConstants.PackageDescriptorFileName);
+    const packageDescriptorPath = Path4.join(contentFolder, NugetConstants.PackageDescriptorFileName);
     const packageDescriptor = {
       $schema: "https://cloud.uipath.com/draft/2024-12/package-descriptor",
       files: {
-        [NugetConstants.OperateFileName]: Path3.join(NugetConstants.ContentFolderName, NugetConstants.OperateFileName),
-        "entry-points.json": Path3.join(NugetConstants.ContentFolderName, "entry-points.json"),
-        "bindings.json": Path3.join(NugetConstants.ContentFolderName, "bindings_v2.json")
+        [NugetConstants.OperateFileName]: Path4.join(NugetConstants.ContentFolderName, NugetConstants.OperateFileName),
+        "entry-points.json": Path4.join(NugetConstants.ContentFolderName, "entry-points.json"),
+        "bindings.json": Path4.join(NugetConstants.ContentFolderName, "bindings_v2.json")
       }
     };
     const packageDescriptorJson = JSON.stringify(packageDescriptor, null, 2);
     await this.fileSystem.writeFile(packageDescriptorPath, packageDescriptorJson);
   }
+  async describeBundleProblemAsync(fullBundlePath, declaredMainFile) {
+    const bundleStat = await this.fileSystem.stat(fullBundlePath);
+    if (!bundleStat) {
+      return ERROR_MESSAGES.BUNDLE_NOT_FOUND(fullBundlePath);
+    }
+    if (!bundleStat.isDirectory()) {
+      return ERROR_MESSAGES.BUNDLE_NOT_DIRECTORY(fullBundlePath);
+    }
+    return this.describeBundleEntryProblemAsync(fullBundlePath, declaredMainFile);
+  }
+  async describeBundleEntryProblemAsync(fullBundlePath, declaredMainFile) {
+    if (declaredMainFile !== undefined && typeof declaredMainFile !== "string") {
+      return ERROR_MESSAGES.MAIN_FILE_INVALID_TYPE;
+    }
+    if (await this.resolveMainFileAsync(fullBundlePath, declaredMainFile)) {
+      return null;
+    }
+    return declaredMainFile !== undefined ? ERROR_MESSAGES.MAIN_FILE_NOT_IN_BUNDLE(fullBundlePath, declaredMainFile) : ERROR_MESSAGES.BUNDLE_NO_ENTRY_POINT(fullBundlePath);
+  }
+  async resolveMainFileAsync(folder, declaredMainFile) {
+    if (declaredMainFile === undefined) {
+      return this.findEntryPointAsync(folder);
+    }
+    return resolveHtmlEntryPoint(this.fileSystem, folder, declaredMainFile);
+  }
+  async findEntryPointAsync(folder) {
+    for (const candidate of HTML_ENTRY_POINT_CANDIDATES) {
+      const resolved = await resolveHtmlEntryPoint(this.fileSystem, folder, candidate);
+      if (resolved !== null)
+        return resolved;
+    }
+    return null;
+  }
+  alignEntryPoint(content, mainFile) {
+    const document = JSON.parse(content);
+    if (typeof document !== "object" || document === null || !("entryPoints" in document) || !Array.isArray(document.entryPoints)) {
+      throw new Error("Invalid entry-points.json: expected an entryPoints array.");
+    }
+    const primary = document.entryPoints[0];
+    if (typeof primary !== "object" || primary === null || Array.isArray(primary)) {
+      throw new Error("Invalid entry-points.json: expected a primary entry object.");
+    }
+    return JSON.stringify({
+      ...document,
+      entryPoints: [
+        { ...primary, filePath: mainFile },
+        ...document.entryPoints.slice(1)
+      ]
+    }, null, 2);
+  }
   createDefaultEntryPoints(mainFile) {
     const uniqueId = this.generateUniqueId();
     const entryPoints = {
@@ -717,7 +817,7 @@ class CodedAppStrategy {
 import {
   NugetConstants as NugetConstants2,
   NugetPackager as NugetPackager2,
-  Path as Path4,
+  Path as Path5,
   ProjectTypes as ProjectTypes2,
   TargetFramework as TargetFramework2
 } from "@uipath/solutionpackager-tool-core";
@@ -728,7 +828,7 @@ class JsAppsStrategy {
   }
   async validateAsync(args) {
     const { projectPath, logger } = args;
-    const appFolder = Path4.join(projectPath, APP_FOLDER_NAME);
+    const appFolder = Path5.join(projectPath, APP_FOLDER_NAME);
     const exists = await this.fileSystem.exists(appFolder);
     if (!exists) {
       const message = ERROR_MESSAGES.APP_FOLDER_NOT_FOUND(appFolder);
@@ -752,7 +852,7 @@ class JsAppsStrategy {
   async packageAsync(args) {
     const { projectPath, manifest, outputPath, packageInfo, logger } = args;
     logger?.info(`Packaging JS variant: ${packageInfo.id}@${packageInfo.version}`);
-    const appFolder = Path4.join(projectPath, APP_FOLDER_NAME);
+    const appFolder = Path5.join(projectPath, APP_FOLDER_NAME);
     logger?.progress("Validating .app folder...");
     const appFolderExists = await this.fileSystem.exists(appFolder);
     if (!appFolderExists) {
@@ -762,9 +862,9 @@ class JsAppsStrategy {
     if (!appFolderStat?.isDirectory()) {
       throw new Error(ERROR_MESSAGES.APP_FOLDER_NOT_DIRECTORY(appFolder));
     }
-    const localBuildFolder = Path4.join(outputPath, NugetConstants2.OutputFolderName);
-    const contentFolder = Path4.join(localBuildFolder, NugetConstants2.ContentFolderName);
-    const contentAppFolder = Path4.join(contentFolder, CONTENT_APP_FOLDER_NAME);
+    const localBuildFolder = Path5.join(outputPath, NugetConstants2.OutputFolderName);
+    const contentFolder = Path5.join(localBuildFolder, NugetConstants2.ContentFolderName);
+    const contentAppFolder = Path5.join(contentFolder, CONTENT_APP_FOLDER_NAME);
     await this.fileSystem.mkdir(contentFolder);
     try {
       logger?.progress("Copying .app folder into content/app...");
@@ -773,7 +873,7 @@ class JsAppsStrategy {
       await this.prepareMetadataFiles(contentFolder, contentAppFolder, packageInfo, manifest, projectPath);
       logger?.progress("Creating NuGet package...");
       const nupkgFileName = `${packageInfo.id}.${packageInfo.version}.nupkg`;
-      const nupkgPath = Path4.join(outputPath, nupkgFileName);
+      const nupkgPath = Path5.join(outputPath, nupkgFileName);
       const packager = new NugetPackager2(this.fileSystem);
       const result = await packager.packAsync(localBuildFolder, packageInfo, nupkgPath);
       logger?.info(`Package created successfully: ${result.outputPath}`);
@@ -789,7 +889,7 @@ class JsAppsStrategy {
   async prepareMetadataFiles(contentFolder, _contentAppFolder, _packageInfo, _manifest, projectPath) {
     const mainFile = "index.html";
     const mainRelativeToContent = `${CONTENT_APP_FOLDER_NAME}/${mainFile}`;
-    const operatePath = Path4.join(contentFolder, NugetConstants2.OperateFileName);
+    const operatePath = Path5.join(contentFolder, NugetConstants2.OperateFileName);
     const operateModel = {
       projectId: await ensureWebAppProjectId(this.fileSystem, projectPath),
       main: mainRelativeToContent,
@@ -803,8 +903,8 @@ class JsAppsStrategy {
     };
     const operateJson = JSON.stringify(operateModel, null, 2);
     await this.fileSystem.writeFile(operatePath, operateJson);
-    const manifestSourcePath = Path4.join(projectPath, WEBAPP_MANIFEST_FILE_NAME);
-    const manifestDestPath = Path4.join(contentFolder, WEBAPP_MANIFEST_FILE_NAME);
+    const manifestSourcePath = Path5.join(projectPath, WEBAPP_MANIFEST_FILE_NAME);
+    const manifestDestPath = Path5.join(contentFolder, WEBAPP_MANIFEST_FILE_NAME);
     const manifestExists = await this.fileSystem.exists(manifestSourcePath);
     if (manifestExists) {
       const manifestContent = await this.fileSystem.readFile(manifestSourcePath);
@@ -812,8 +912,8 @@ class JsAppsStrategy {
         await this.fileSystem.writeFile(manifestDestPath, manifestContent);
       }
     }
-    const uipathJsonSourcePath = Path4.join(projectPath, "uipath.json");
-    const uipathJsonDestPath = Path4.join(contentFolder, "uipath.json");
+    const uipathJsonSourcePath = Path5.join(projectPath, "uipath.json");
+    const uipathJsonDestPath = Path5.join(contentFolder, "uipath.json");
     const uipathJsonExists = await this.fileSystem.exists(uipathJsonSourcePath);
     if (uipathJsonExists) {
       const uipathJsonContent = await this.fileSystem.readFile(uipathJsonSourcePath);
@@ -821,20 +921,20 @@ class JsAppsStrategy {
         await this.fileSystem.writeFile(uipathJsonDestPath, uipathJsonContent);
       }
     }
-    const bindingsPath = Path4.join(contentFolder, "bindings.json");
+    const bindingsPath = Path5.join(contentFolder, "bindings.json");
     const bindingsExists = await this.fileSystem.exists(bindingsPath);
     if (!bindingsExists) {
       const bindingsJson = JSON.stringify({ version: "1.0", resources: [] }, null, 2);
       await this.fileSystem.writeFile(bindingsPath, bindingsJson);
     }
-    const bindingsV2Path = Path4.join(contentFolder, "bindings_v2.json");
+    const bindingsV2Path = Path5.join(contentFolder, "bindings_v2.json");
     const bindingsV2Exists = await this.fileSystem.exists(bindingsV2Path);
     if (!bindingsV2Exists) {
       const bindingsV2Json = JSON.stringify({ version: "2.0", resources: [] }, null, 2);
       await this.fileSystem.writeFile(bindingsV2Path, bindingsV2Json);
     }
-    const entryPointsPath = Path4.join(contentFolder, "entry-points.json");
-    const projectEntryPointsPath = Path4.join(projectPath, "entry-points.json");
+    const entryPointsPath = Path5.join(contentFolder, "entry-points.json");
+    const projectEntryPointsPath = Path5.join(projectPath, "entry-points.json");
     let entryPointsContent;
     const projectEntryPointsExists = await this.fileSystem.exists(projectEntryPointsPath);
     if (projectEntryPointsExists) {
@@ -848,12 +948,12 @@ class JsAppsStrategy {
       entryPointsContent = this.createDefaultEntryPoints(mainRelativeToContent);
     }
     await this.fileSystem.writeFile(entryPointsPath, entryPointsContent);
-    const packageDescriptorPath = Path4.join(contentFolder, NugetConstants2.PackageDescriptorFileName);
+    const packageDescriptorPath = Path5.join(contentFolder, NugetConstants2.PackageDescriptorFileName);
     const packageDescriptor = {
       files: {
-        [NugetConstants2.OperateFileName]: Path4.join(NugetConstants2.ContentFolderName, NugetConstants2.OperateFileName),
-        "entry-points.json": Path4.join(NugetConstants2.ContentFolderName, "entry-points.json"),
-        "bindings.json": Path4.join(NugetConstants2.ContentFolderName, "bindings_v2.json")
+        [NugetConstants2.OperateFileName]: Path5.join(NugetConstants2.ContentFolderName, NugetConstants2.OperateFileName),
+        "entry-points.json": Path5.join(NugetConstants2.ContentFolderName, "entry-points.json"),
+        "bindings.json": Path5.join(NugetConstants2.ContentFolderName, "bindings_v2.json")
       }
     };
     const packageDescriptorJson = JSON.stringify(packageDescriptor, null, 2);
@@ -983,7 +1083,7 @@ class WebAppTool extends ProjectTool2 {
       let manifest;
       let strategy;
       try {
-        const prepared = await this.getManifestAndStrategy(options.projectPath);
+        const prepared = await this.getManifestAndStrategy(options.projectPath, options.codedBundle);
         manifest = prepared.manifest;
         strategy = prepared.strategy;
       } catch (error) {
@@ -1013,20 +1113,33 @@ class WebAppTool extends ProjectTool2 {
       await this._temporaryStorage.cleanup();
     } catch {}
   }
-  async getManifestAndStrategy(projectPath) {
-    const manifestPath = Path5.join(projectPath, WEBAPP_MANIFEST_FILE_NAME);
+  async getManifestAndStrategy(projectPath, codedBundle) {
+    const manifestPath = Path6.join(projectPath, WEBAPP_MANIFEST_FILE_NAME);
     const manifestExists = await this.fileSystem.exists(manifestPath);
-    if (!manifestExists) {
+    if (!manifestExists && !codedBundle) {
       throw new Error(ERROR_MESSAGES.MANIFEST_NOT_FOUND(WEBAPP_MANIFEST_FILE_NAME));
     }
-    const projectJsonPath = Path5.join(projectPath, PROJECT_JSON_FILE);
+    const projectJsonPath = Path6.join(projectPath, PROJECT_JSON_FILE);
     if (await this.fileSystem.exists(projectJsonPath)) {
       throw new Error(ERROR_MESSAGES.PROJECT_JSON_FOUND);
     }
-    const manifest = await loadWebAppManifest2(this.fileSystem, projectPath);
+    let manifest = manifestExists ? await loadWebAppManifest2(this.fileSystem, projectPath) : {
+      type: "Coded" /* Coded */,
+      solutionResourceSubType: "Coded" /* Coded */,
+      config: { isCompiled: true }
+    };
     if (!manifest) {
       throw new Error(ERROR_MESSAGES.MANIFEST_LOAD_FAILED(WEBAPP_MANIFEST_FILE_NAME));
     }
+    if (codedBundle) {
+      if (manifest.type !== "Coded" /* Coded */) {
+        throw new Error("A coded bundle requires a Coded webAppManifest.json.");
+      }
+      manifest = {
+        ...manifest,
+        config: { ...manifest.config, ...codedBundle }
+      };
+    }
     const strategy = VariantStrategyFactory.createStrategy(manifest, this.fileSystem);
     return { manifest, strategy };
   }
@@ -1086,4 +1199,4 @@ export {
   validateActionSchema
 };
 
-//# debugId=E7C8B1E2C5B0339C64756E2164756E21
+//# debugId=373EDDEBABAD6ECD64756E2164756E21

package/dist/constants.d.ts

@@ -1,3 +1,4 @@
+export { isBundleRelativePath, isCanonicalBundleChild, isHtmlEntryPointPath, normalizeBundlePath, resolveHtmlEntryPoint, } from "./utils/bundle-path.js";
 /**
  * Constants used throughout the WebApp tool implementation
  */
@@ -29,6 +30,12 @@ export declare const TARGET_JS_RUNTIME = "JS";
  * Default entry point type
  */
 export declare const DEFAULT_ENTRY_POINT_TYPE = "api";
+/**
+ * HTML entry points a packed coded app may boot from, in the order
+ * `operate.json`'s `main` is resolved. A bundle with none of them produces an
+ * app that cannot start, so pack refuses it rather than shipping it.
+ */
+export declare const HTML_ENTRY_POINT_CANDIDATES: readonly ["index.html", "main.html", "app.html"];
 /**
  * Error messages
  */
@@ -38,6 +45,12 @@ export declare const ERROR_MESSAGES: {
     readonly MANIFEST_LOAD_FAILED: (file: string) => string;
     readonly BUNDLE_NOT_FOUND: (path: string) => string;
     readonly BUNDLE_NOT_DIRECTORY: (path: string) => string;
+    readonly BUNDLE_OUTSIDE_PROJECT: (path: string) => string;
+    readonly BUNDLE_NO_ENTRY_POINT: (path: string) => string;
+    readonly MAIN_FILE_INVALID_TYPE: "Invalid webAppManifest.json: config.mainFile must be a string naming an HTML file, or be omitted.";
+    readonly MAIN_FILE_NOT_IN_BUNDLE: (path: string, mainFile: string) => string;
+    readonly MAIN_FILE_LOST: (path: string, mainFile: string) => string;
+    readonly BUNDLE_ENTRY_POINT_LOST: (path: string) => string;
     readonly APP_FOLDER_NOT_FOUND: (path: string) => string;
     readonly APP_FOLDER_NOT_DIRECTORY: (path: string) => string;
     readonly BUILD_NOT_SUPPORTED: "Build execution (isCompiled=false) is not yet supported. Please build the project manually and set isCompiled=true.";