@uipath/packager-tool-webapp 1.202.0-preview.159 → 1.203.0-preview.160

package/dist/action-schema/describe-action-app.d.ts

@@ -0,0 +1,11 @@
+import type { IFileSystem, ProjectResourceContribution } from "@uipath/solutionpackager-tool-core";
+/**
+ * The AppV2 side of the project resource contribution contract: reads the
+ * project's own `webAppManifest.json` + `action-schema.json` and returns plain
+ * data. Never reads or writes the solution's resource JSON — solution-tool's
+ * driver does that (AGENTS.md Hard Rule #19).
+ *
+ * Errors are returned, not thrown, so one broken file reports alongside every
+ * other project's problems instead of aborting the walk.
+ */
+export declare function describeActionApp(projectDir: string, fs: IFileSystem): Promise<ProjectResourceContribution>;

package/dist/action-schema/index.d.ts

@@ -0,0 +1,28 @@
+/**
+ * AppV2 CodedAction domain — the file formats, the schema transform, and the
+ * project resource contribution built on them. Lives here (not in a `*-tool`)
+ * because AGENTS.md Hard Rule #19 puts a project type's formats at the layer
+ * that owns the type. Own subpath entry, node target, so the browser bundle in
+ * `src/index.ts` never pulls it.
+ *
+ * The subpath build keeps `zod`, `@uipath/common` and
+ * `@uipath/solutionpackager-tool-core` external. `@uipath/common` has to stay
+ * external — its singletons are shared across bundles through
+ * `Symbol.for()` keys, and a second inlined copy would split that state — and
+ * the other two follow the same rule the root entry already uses. All three
+ * are therefore declared as `peerDependencies` (the shape
+ * `packager-tool-flow` already uses for its own externals), so the published
+ * package states the contract instead of leaving bare imports for whatever
+ * host happens to provide them. So a consumer resolves them itself:
+ * `codedapp-tool` therefore declares `zod` in its own `devDependencies` even
+ * though nothing under `codedapp-tool/src` imports it, and `knip.json` lists
+ * it under that package's `ignoreDependencies` for exactly that reason. Root
+ * `tsconfig.base.json` aliases this subpath to source, so the consumer
+ * compiles these files and needs the dependency at build time, not just at
+ * runtime.
+ */
+export { describeActionApp } from "./describe-action-app.js";
+export { ACTION_SCHEMA_FILE_NAME, isActionApp, loadWebAppManifest, WEBAPP_MANIFEST_FILE_NAME, type WebAppManifestLoad, } from "./manifest-helpers.js";
+export { parseActionSchema } from "./parse.js";
+export { type JsonActionSchema, JsonActionSchemaValidator, JsonDataType, JsonFormatType, type JsonSchemaProperty, JsonSchemaPropertySchema, type ParsedActionPropertySchema, type ParsedActionSchema, VBDataType, VbArgumentCollectionType, VbArgumentDataTypeNamespace, } from "./types.js";
+export { WebAppContributingToolFactory } from "./webapp-contributing-tool-factory.js";

package/dist/action-schema/index.js

@@ -0,0 +1,1063 @@
+// src/action-schema/describe-action-app.ts
+import { catchError as catchError2 } from "@uipath/common";
+
+// src/action-schema/manifest-helpers.ts
+import { catchError } from "@uipath/common";
+
+// src/models/webapp-manifest.ts
+var WebAppVariantType;
+((WebAppVariantType2) => {
+  WebAppVariantType2["Coded"] = "Coded";
+  WebAppVariantType2["JS"] = "JS";
+})(WebAppVariantType ||= {});
+var WEBAPP_MANIFEST_FILE_NAME = "webAppManifest.json";
+
+// src/action-schema/manifest-helpers.ts
+var ACTION_SCHEMA_FILE_NAME = "action-schema.json";
+var VARIANTS = Object.values(WebAppVariantType);
+var SUBTYPE_BY_VARIANT = {
+  ["Coded" /* Coded */]: {
+    app: "Coded" /* Coded */,
+    action: "CodedAction" /* CodedAction */
+  },
+  ["JS" /* JS */]: { app: "JS", action: "JS Action" }
+};
+var ACTION_SUBTYPES = new Set(Object.values(SUBTYPE_BY_VARIANT).map((row) => row.action));
+async function loadWebAppManifest(fs, projectDir) {
+  const manifestPath = fs.path.join(projectDir, WEBAPP_MANIFEST_FILE_NAME);
+  const [readError, raw] = await catchError(fs.readFile(manifestPath, "utf-8"));
+  if (readError)
+    return { state: "invalid", reason: readError.message };
+  if (raw === null || raw === undefined)
+    return { state: "missing" };
+  if (raw === "")
+    return { state: "invalid", reason: "the file is empty" };
+  const [parseError, parsed] = catchError(() => JSON.parse(raw));
+  if (parseError)
+    return { state: "invalid", reason: parseError.message };
+  const shapeError = manifestShapeError(parsed);
+  if (shapeError)
+    return { state: "invalid", reason: shapeError };
+  return { state: "ok", manifest: parsed };
+}
+function manifestShapeError(parsed) {
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+    return "the file is not a JSON object";
+  }
+  const type = parsed.type;
+  if (typeof type !== "string" || !VARIANTS.includes(type)) {
+    return `"type" must be one of ${VARIANTS.join(", ")} (got ${JSON.stringify(type)})`;
+  }
+  return;
+}
+function isActionApp(manifest) {
+  if (!manifest)
+    return false;
+  if (ACTION_SUBTYPES.has(manifest.solutionResourceSubType))
+    return true;
+  const config = manifest.config;
+  return config?.isActionApp === true;
+}
+function appSubTypeFor(manifest) {
+  const row = SUBTYPE_BY_VARIANT[manifest?.type ?? "Coded" /* Coded */];
+  return isActionApp(manifest) ? row.action : row.app;
+}
+
+// src/action-schema/parse.ts
+import { z as z2 } from "zod";
+
+// src/action-schema/types.ts
+import { z } from "zod";
+var JsonDataType;
+((JsonDataType2) => {
+  JsonDataType2["string"] = "string";
+  JsonDataType2["integer"] = "integer";
+  JsonDataType2["number"] = "number";
+  JsonDataType2["boolean"] = "boolean";
+  JsonDataType2["array"] = "array";
+  JsonDataType2["object"] = "object";
+  JsonDataType2["file"] = "file";
+  JsonDataType2["ContentValidationData"] = "ContentValidationData";
+})(JsonDataType ||= {});
+var JsonFormatType;
+((JsonFormatType2) => {
+  JsonFormatType2["uuid"] = "uuid";
+  JsonFormatType2["date"] = "date";
+})(JsonFormatType ||= {});
+var VbArgumentCollectionType;
+((VbArgumentCollectionType2) => {
+  VbArgumentCollectionType2["array"] = "Array";
+})(VbArgumentCollectionType ||= {});
+var VbArgumentDataTypeNamespace;
+((VbArgumentDataTypeNamespace2) => {
+  VbArgumentDataTypeNamespace2["system"] = "system";
+})(VbArgumentDataTypeNamespace ||= {});
+var VBDataType;
+((VBDataType2) => {
+  VBDataType2["string"] = "System.String";
+  VBDataType2["int64"] = "System.Int64";
+  VBDataType2["boolean"] = "System.Boolean";
+  VBDataType2["decimal"] = "System.Decimal";
+  VBDataType2["dateOnly"] = "System.DateOnly";
+  VBDataType2["guid"] = "System.Guid";
+  VBDataType2["object"] = "System.Object";
+  VBDataType2["iresource"] = "UiPath.Platform.ResourceHandling.IResource";
+  VBDataType2["ContentValidationData"] = "UiPath.DocumentProcessing.Contracts.Actions.ContentValidationData";
+})(VBDataType ||= {});
+var JsonSchemaPropertySchema = z.lazy(() => z.object({
+  type: z.enum([
+    "string" /* string */,
+    "integer" /* integer */,
+    "number" /* number */,
+    "boolean" /* boolean */,
+    "array" /* array */,
+    "object" /* object */,
+    "file" /* file */,
+    "ContentValidationData" /* ContentValidationData */
+  ], {
+    message: "Invalid property type — expected string, integer, number, boolean, array, object, file, or ContentValidationData"
+  }),
+  required: z.boolean().optional(),
+  description: z.string().optional(),
+  format: z.enum(["uuid" /* uuid */, "date" /* date */], {
+    message: "Invalid property format — expected uuid or date"
+  }).optional(),
+  items: JsonSchemaPropertySchema.optional(),
+  properties: z.record(z.string(), JsonSchemaPropertySchema).optional()
+}).refine((data) => data.type !== "array" /* array */ || !!data.items, {
+  message: "array type requires an `items` schema"
+}).refine((data) => !data.format || data.type === "string" /* string */, {
+  message: "`format` is only valid on string types"
+}).refine((data) => data.type !== "array" /* array */ || !data.items || data.items.type !== "array" /* array */, {
+  message: "nested arrays are not supported"
+}));
+var JsonSchemaObjectSchema = z.object({
+  type: z.literal("object", {
+    message: "action-schema sections must have type: 'object'"
+  }),
+  properties: z.record(z.string(), JsonSchemaPropertySchema, {
+    message: "section `properties` must be a string-keyed object"
+  })
+});
+var OutcomesSectionSchema = z.object({
+  type: z.literal("object", {
+    message: "action-schema sections must have type: 'object'"
+  }),
+  properties: z.record(z.string(), z.looseObject({}).optional().default({}), {
+    message: "section `properties` must be a string-keyed object"
+  })
+});
+var JsonActionSchemaValidator = z.object({
+  inputs: JsonSchemaObjectSchema,
+  outputs: JsonSchemaObjectSchema,
+  inOuts: JsonSchemaObjectSchema,
+  outcomes: OutcomesSectionSchema
+}, {
+  message: "action-schema.json must define `inputs`, `outputs`, `inOuts`, and `outcomes`"
+});
+
+// src/action-schema/parse.ts
+function parseActionSchema(raw) {
+  const parsed = JSON.parse(raw);
+  const validated = validate(parsed);
+  return transformToParsedSchema(validated);
+}
+function validate(schema) {
+  try {
+    return JsonActionSchemaValidator.parse(schema);
+  } catch (err) {
+    if (err instanceof z2.ZodError) {
+      const details = err.issues.map((issue) => {
+        const path = issue.path.length > 0 ? issue.path.join(".") : "root";
+        return `  - ${path}: ${issue.message}`;
+      }).join(`
+`);
+      throw new Error(`Invalid action-schema.json:
+${details}`);
+    }
+    throw err;
+  }
+}
+function fnv1a32(text, seed = 0) {
+  let hash = (2166136261 ^ seed) >>> 0;
+  for (let i = 0;i < text.length; i++) {
+    hash = (hash ^ text.charCodeAt(i)) >>> 0;
+    hash = hash + (hash << 1 >>> 0) + (hash << 4 >>> 0) + (hash << 7 >>> 0) + (hash << 8 >>> 0) + (hash << 24 >>> 0) >>> 0;
+  }
+  return hash >>> 0;
+}
+function hex32(n) {
+  return n.toString(16).padStart(8, "0");
+}
+function deterministicUuid(path) {
+  const a = hex32(fnv1a32(path, 0));
+  const b = hex32(fnv1a32(path, 1));
+  const c = hex32(fnv1a32(path, 2));
+  const d = hex32(fnv1a32(path, 3));
+  const timeLow = a;
+  const timeMid = b.slice(0, 4);
+  const timeHiAndVersion = `5${b.slice(5, 8)}`;
+  const variantBits = (parseInt(c[0], 16) & 3 | 8).toString(16);
+  const clockSeq = `${variantBits}${c.slice(1, 4)}`;
+  const node = `${c.slice(4, 8)}${d}`;
+  return `${timeLow}-${timeMid}-${timeHiAndVersion}-${clockSeq}-${node}`;
+}
+function mapJsonTypeToSystemType(type, format) {
+  if (format === "uuid" /* uuid */)
+    return "System.Guid" /* guid */;
+  if (format === "date" /* date */)
+    return "System.DateOnly" /* dateOnly */;
+  switch (type) {
+    case "string" /* string */:
+      return "System.String" /* string */;
+    case "integer" /* integer */:
+      return "System.Int64" /* int64 */;
+    case "number" /* number */:
+      return "System.Decimal" /* decimal */;
+    case "boolean" /* boolean */:
+      return "System.Boolean" /* boolean */;
+    case "object" /* object */:
+      return "System.Object" /* object */;
+    case "file" /* file */:
+      return "UiPath.Platform.ResourceHandling.IResource" /* iresource */;
+    case "ContentValidationData" /* ContentValidationData */:
+      return "UiPath.DocumentProcessing.Contracts.Actions.ContentValidationData" /* ContentValidationData */;
+    default:
+      throw new Error(`Unsupported action schema JSON data type: ${type}`);
+  }
+}
+function transformProperty(path, name, propDef) {
+  const isArray = propDef.type === "array" /* array */;
+  const itemType = isArray && propDef.items ? propDef.items.type : propDef.type;
+  const itemFormat = isArray && propDef.items ? propDef.items.format : propDef.format;
+  let properties = [];
+  if (propDef.type === "object" /* object */ && propDef.properties) {
+    properties = Object.keys(propDef.properties).map((child) => transformProperty(`${path}.${child}`, child, propDef.properties?.[child]));
+  } else if (propDef.type === "array" /* array */ && propDef.items && propDef.items.type === "object" /* object */ && propDef.items.properties) {
+    const nested = propDef.items.properties;
+    properties = Object.keys(nested).map((child) => transformProperty(`${path}[].${child}`, child, nested[child]));
+  }
+  return {
+    name,
+    key: deterministicUuid(path),
+    required: propDef.required ?? false,
+    description: propDef.description,
+    version: 0,
+    typeNamespace: "system" /* system */,
+    isList: isArray,
+    collectionDataType: isArray ? "Array" /* array */ : null,
+    type: mapJsonTypeToSystemType(itemType, itemFormat),
+    properties
+  };
+}
+function transformToParsedSchema(schema) {
+  const transformSection = (section, sectionName) => section?.properties ? Object.keys(section.properties).map((name) => transformProperty(`${sectionName}.${name}`, name, section.properties[name])) : [];
+  const outcomes = schema.outcomes?.properties ? Object.keys(schema.outcomes.properties).map((name) => ({
+    name,
+    key: deterministicUuid(`outcomes.${name}`),
+    required: false,
+    type: "System.String" /* string */,
+    typeNamespace: "system" /* system */,
+    isList: false,
+    properties: [],
+    version: 0
+  })) : [];
+  return {
+    key: deterministicUuid("root"),
+    version: 0,
+    description: "Action Schema",
+    id: `ID${deterministicUuid("root.id").replace(/-/g, "")}`,
+    name: "ActionSchema",
+    inputs: transformSection(schema.inputs, "inputs"),
+    outputs: transformSection(schema.outputs, "outputs"),
+    inOuts: transformSection(schema.inOuts, "inOuts"),
+    outcomes
+  };
+}
+
+// src/action-schema/describe-action-app.ts
+var ARTEFACT_KIND_APP = "app";
+var SPEC_KEY_ACTION_SCHEMA = "actionSchema";
+async function describeActionApp(projectDir, fs) {
+  const load = await loadWebAppManifest(fs, projectDir);
+  if (load.state === "invalid") {
+    const manifestPath = fs.path.join(projectDir, WEBAPP_MANIFEST_FILE_NAME);
+    return {
+      errors: [
+        {
+          code: "webapp_manifest_invalid",
+          message: `${WEBAPP_MANIFEST_FILE_NAME} at ${manifestPath} could not be read: ${load.reason}.`,
+          instructions: `Make ${manifestPath} readable and a valid manifest (a JSON object whose "type" is Coded or JS), or re-scaffold the project with 'uip codedapp init <project-path>', then re-run the command.`
+        }
+      ]
+    };
+  }
+  const manifest = load.state === "ok" ? load.manifest : null;
+  const projectSubType = appSubTypeFor(manifest);
+  if (!isActionApp(manifest)) {
+    return {
+      projectSubType,
+      specPatch: [
+        {
+          kind: ARTEFACT_KIND_APP,
+          values: { [SPEC_KEY_ACTION_SCHEMA]: null }
+        }
+      ]
+    };
+  }
+  const schemaPath = fs.path.join(projectDir, ACTION_SCHEMA_FILE_NAME);
+  const [readError, raw] = await catchError2(fs.readFile(schemaPath, "utf-8"));
+  if (readError) {
+    return {
+      projectSubType,
+      errors: [
+        {
+          code: "action_schema_unreadable",
+          message: `${ACTION_SCHEMA_FILE_NAME} at ${schemaPath} could not be read: ${readError.message}.`,
+          instructions: `Make ${schemaPath} readable, then re-run the command.`
+        }
+      ]
+    };
+  }
+  if (raw === null || raw === undefined) {
+    return {
+      projectSubType,
+      errors: [
+        {
+          code: "action_schema_missing",
+          message: `Coded Action project is missing ${ACTION_SCHEMA_FILE_NAME}: ${schemaPath}.`,
+          instructions: `Create ${ACTION_SCHEMA_FILE_NAME} defining inputs / outputs / inOuts / outcomes, then re-run the command.`
+        }
+      ]
+    };
+  }
+  const [parseError, parsed] = catchError2(() => parseActionSchema(raw));
+  if (parseError) {
+    return {
+      projectSubType,
+      errors: [
+        {
+          code: "action_schema_invalid",
+          message: `${ACTION_SCHEMA_FILE_NAME} at ${schemaPath} is not a valid action schema: ${parseError.message}`,
+          instructions: `Fix the reported section or property in ${schemaPath}, then re-run the command.`
+        }
+      ]
+    };
+  }
+  return {
+    projectSubType,
+    specPatch: [
+      {
+        kind: ARTEFACT_KIND_APP,
+        values: { [SPEC_KEY_ACTION_SCHEMA]: JSON.stringify(parsed) }
+      }
+    ]
+  };
+}
+// src/webapp-tool-factory.ts
+import {
+  ProjectTypes as ProjectTypes3
+} from "@uipath/solutionpackager-tool-core";
+
+// src/webapp-tool.ts
+import {
+  Path as Path5,
+  ProjectTool,
+  TemporaryStorageService,
+  ToolErrorCodes,
+  ToolResult
+} from "@uipath/solutionpackager-tool-core";
+
+// src/constants.ts
+var PROJECT_JSON_FILE = "project.json";
+var DEFAULT_BUNDLE_PATH = "source/dist";
+var APP_FOLDER_NAME = ".app";
+var CONTENT_APP_FOLDER_NAME = "app";
+var TARGET_RUNTIME = "Coded";
+var TARGET_JS_RUNTIME = "JS";
+var DEFAULT_ENTRY_POINT_TYPE = "api";
+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.`,
+  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.",
+  VALIDATION_FAILED: (context) => `Validation failed: ${context}`,
+  PACKING_FAILED: (context) => `An error occurred while packing WebApp project: ${context}`,
+  PACKAGE_NAME_REQUIRED: "Package name is required",
+  PACKAGE_VERSION_REQUIRED: "Package version is required",
+  PROJECT_PATH_REQUIRED: "Project path is required",
+  OUTPUT_PATH_REQUIRED: "Output path is required"
+};
+
+// src/strategies/coded-app-strategy.ts
+import {
+  NugetConstants,
+  NugetPackager,
+  Path as Path3,
+  ProjectTypes,
+  TargetFramework
+} from "@uipath/solutionpackager-tool-core";
+
+// src/utils/fs-helpers.ts
+import { Path } 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 stat = await fileSystem.stat(sourceEntry);
+    if (stat?.isDirectory()) {
+      await copyDirectoryAsync(fileSystem, sourceEntry, destEntry);
+    } else if (stat?.isFile()) {
+      const content = await fileSystem.readFile(sourceEntry);
+      if (content) {
+        await fileSystem.writeFile(destEntry, content);
+      }
+    }
+  }
+}
+
+// src/utils/manifest-loader.ts
+import { Path as Path2 } from "@uipath/solutionpackager-tool-core";
+async function loadWebAppManifest2(fileSystem, projectPath) {
+  const manifestPath = Path2.join(projectPath, WEBAPP_MANIFEST_FILE_NAME);
+  const exists = await fileSystem.exists(manifestPath);
+  if (!exists) {
+    return null;
+  }
+  const content = await fileSystem.readFile(manifestPath);
+  if (!content) {
+    return null;
+  }
+  try {
+    const text = new TextDecoder().decode(content);
+    const manifest = JSON.parse(text);
+    return manifest;
+  } catch (error) {
+    throw new Error(`Failed to parse ${WEBAPP_MANIFEST_FILE_NAME}: ${error instanceof Error ? error.message : String(error)}`);
+  }
+}
+async function ensureWebAppProjectId(fileSystem, projectPath) {
+  const manifest = await loadWebAppManifest2(fileSystem, projectPath);
+  if (manifest && typeof manifest.projectId === "string" && manifest.projectId.length > 0) {
+    return manifest.projectId;
+  }
+  const id = crypto.randomUUID();
+  if (manifest) {
+    const updated = { ...manifest, projectId: id };
+    const manifestPath = Path2.join(projectPath, WEBAPP_MANIFEST_FILE_NAME);
+    await fileSystem.writeFile(manifestPath, `${JSON.stringify(updated, null, 2)}
+`);
+  }
+  return id;
+}
+
+// src/strategies/coded-app-strategy.ts
+class CodedAppStrategy {
+  fileSystem;
+  constructor(fileSystem) {
+    this.fileSystem = fileSystem;
+  }
+  async validateAsync(args) {
+    const { projectPath, manifest, logger } = args;
+    const typed = manifest;
+    let bundlePath = typed.config?.bundlePath;
+    if (typeof bundlePath !== "string" || bundlePath.length === 0) {
+      bundlePath = DEFAULT_BUNDLE_PATH;
+    }
+    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 warnable = logger;
+        if (warnable?.warn) {
+          warnable.warn(message);
+        } else {
+          logger?.info(`Warning: ${message}`);
+        }
+      }
+    }
+  }
+  async packageAsync(args) {
+    const { projectPath, manifest, outputPath, packageInfo, logger } = args;
+    logger?.info(`Packaging Coded variant: ${packageInfo.id}@${packageInfo.version}`);
+    let bundlePath = manifest.config?.bundlePath;
+    if (typeof bundlePath !== "string" || bundlePath.length === 0) {
+      bundlePath = DEFAULT_BUNDLE_PATH;
+    }
+    const isCompiled = manifest.config?.isCompiled ?? true;
+    const fullBundlePath = Path3.join(projectPath, bundlePath);
+    if (isCompiled) {
+      logger?.progress("Validating compiled bundle...");
+      const bundleExists = await this.fileSystem.exists(fullBundlePath);
+      if (!bundleExists) {
+        throw new Error(ERROR_MESSAGES.BUNDLE_NOT_FOUND(fullBundlePath));
+      }
+      const bundleStat = await this.fileSystem.stat(fullBundlePath);
+      if (!bundleStat?.isDirectory()) {
+        throw new Error(ERROR_MESSAGES.BUNDLE_NOT_DIRECTORY(fullBundlePath));
+      }
+    } 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);
+    try {
+      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);
+      logger?.progress("Creating NuGet package...");
+      const nupkgFileName = `${packageInfo.id}.${packageInfo.version}.nupkg`;
+      const nupkgPath = Path3.join(outputPath, nupkgFileName);
+      const packager = new NugetPackager(this.fileSystem);
+      const result = await packager.packAsync(localBuildFolder, packageInfo, nupkgPath);
+      logger?.info(`Package created successfully: ${result.outputPath}`);
+      return result.outputPath;
+    } finally {
+      try {
+        await this.fileSystem.rm(localBuildFolder);
+      } catch (cleanupError) {
+        logger?.error(`Failed to cleanup build folder: ${cleanupError instanceof Error ? cleanupError.message : String(cleanupError)}`);
+      }
+    }
+  }
+  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;
+        }
+      }
+    }
+    const operatePath = Path3.join(contentFolder, NugetConstants.OperateFileName);
+    const operateModel = {
+      projectId: await ensureWebAppProjectId(this.fileSystem, projectPath),
+      main: mainFile,
+      contentType: ProjectTypes.WebApp,
+      targetFramework: TargetFramework.Portable,
+      targetRuntime: TARGET_RUNTIME,
+      runtimeOptions: {
+        requiresUserInteraction: false,
+        isAttended: false
+      }
+    };
+    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");
+    const uipathJsonExists = await this.fileSystem.exists(uipathJsonSourcePath);
+    if (uipathJsonExists) {
+      const uipathJsonContent = await this.fileSystem.readFile(uipathJsonSourcePath, "utf-8");
+      if (uipathJsonContent) {
+        await this.fileSystem.writeFile(uipathJsonDestPath, uipathJsonContent);
+      }
+    }
+    const actionSchemaSourcePath = Path3.join(projectPath, "action-schema.json");
+    const actionSchemaDestPath = Path3.join(contentFolder, "action-schema.json");
+    const actionSchemaExists = await this.fileSystem.exists(actionSchemaSourcePath);
+    if (actionSchemaExists) {
+      const actionSchemaContent = await this.fileSystem.readFile(actionSchemaSourcePath, "utf-8");
+      if (actionSchemaContent) {
+        await this.fileSystem.writeFile(actionSchemaDestPath, actionSchemaContent);
+      }
+    }
+    const bindingsPath = Path3.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 = Path3.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")
+    ];
+    let bindingsV2Json = null;
+    for (const candidate of bindingsCandidatePaths) {
+      if (await this.fileSystem.exists(candidate)) {
+        bindingsV2Json = await this.fileSystem.readFile(candidate, "utf-8");
+        if (bindingsV2Json)
+          break;
+      }
+    }
+    if (!bindingsV2Json && await this.fileSystem.exists(bindingsV2Path)) {
+      bindingsV2Json = await this.fileSystem.readFile(bindingsV2Path, "utf-8");
+    }
+    if (!bindingsV2Json) {
+      bindingsV2Json = JSON.stringify({
+        version: "2.0",
+        resources: []
+      }, null, 2);
+    }
+    await this.fileSystem.writeFile(bindingsV2Path, bindingsV2Json);
+    const entryPointsPath = Path3.join(contentFolder, "entry-points.json");
+    const projectEntryPointsPath = Path3.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;
+      } else {
+        entryPointsContent = this.createDefaultEntryPoints(mainFile);
+      }
+    } else {
+      entryPointsContent = this.createDefaultEntryPoints(mainFile);
+    }
+    await this.fileSystem.writeFile(entryPointsPath, entryPointsContent);
+    const packageDescriptorPath = Path3.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")
+      }
+    };
+    const packageDescriptorJson = JSON.stringify(packageDescriptor, null, 2);
+    await this.fileSystem.writeFile(packageDescriptorPath, packageDescriptorJson);
+  }
+  createDefaultEntryPoints(mainFile) {
+    const uniqueId = this.generateUniqueId();
+    const entryPoints = {
+      $schema: "https://cloud.uipath.com/draft/2024-12/entry-point",
+      $id: "entry-points-doc-001",
+      entryPoints: [
+        {
+          filePath: mainFile,
+          uniqueId,
+          type: DEFAULT_ENTRY_POINT_TYPE,
+          input: {
+            amount: { type: "integer" },
+            id: { type: "string" }
+          },
+          output: {
+            status: { type: "string" }
+          }
+        }
+      ]
+    };
+    return JSON.stringify(entryPoints, null, 2);
+  }
+  generateUniqueId() {
+    const randomBytes = new Uint8Array(16);
+    if (typeof crypto !== "undefined" && crypto.getRandomValues) {
+      crypto.getRandomValues(randomBytes);
+    } else {
+      throw new Error("crypto.getRandomValues is not available");
+    }
+    randomBytes[6] = randomBytes[6] & 15 | 64;
+    randomBytes[8] = randomBytes[8] & 63 | 128;
+    const hex = Array.from(randomBytes).map((b) => b.toString(16).padStart(2, "0")).join("");
+    return [
+      hex.substring(0, 8),
+      hex.substring(8, 12),
+      hex.substring(12, 16),
+      hex.substring(16, 20),
+      hex.substring(20, 32)
+    ].join("-");
+  }
+}
+
+// src/strategies/js-apps-strategy.ts
+import {
+  NugetConstants as NugetConstants2,
+  NugetPackager as NugetPackager2,
+  Path as Path4,
+  ProjectTypes as ProjectTypes2,
+  TargetFramework as TargetFramework2
+} from "@uipath/solutionpackager-tool-core";
+class JsAppsStrategy {
+  fileSystem;
+  constructor(fileSystem) {
+    this.fileSystem = fileSystem;
+  }
+  async validateAsync(args) {
+    const { projectPath, logger } = args;
+    const appFolder = Path4.join(projectPath, APP_FOLDER_NAME);
+    const exists = await this.fileSystem.exists(appFolder);
+    if (!exists) {
+      const message = ERROR_MESSAGES.APP_FOLDER_NOT_FOUND(appFolder);
+      if (logger?.warn) {
+        logger.warn(message);
+      } else {
+        logger?.info(`Warning: ${message}`);
+      }
+      return;
+    }
+    const stat = await this.fileSystem.stat(appFolder);
+    if (!stat?.isDirectory()) {
+      const message = ERROR_MESSAGES.APP_FOLDER_NOT_DIRECTORY(appFolder);
+      if (logger?.warn) {
+        logger.warn(message);
+      } else {
+        logger?.info(`Warning: ${message}`);
+      }
+    }
+  }
+  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);
+    logger?.progress("Validating .app folder...");
+    const appFolderExists = await this.fileSystem.exists(appFolder);
+    if (!appFolderExists) {
+      throw new Error(ERROR_MESSAGES.APP_FOLDER_NOT_FOUND(appFolder));
+    }
+    const appFolderStat = await this.fileSystem.stat(appFolder);
+    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);
+    await this.fileSystem.mkdir(contentFolder);
+    try {
+      logger?.progress("Copying .app folder into content/app...");
+      await copyDirectoryAsync(this.fileSystem, appFolder, contentAppFolder);
+      logger?.progress("Preparing metadata files...");
+      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 packager = new NugetPackager2(this.fileSystem);
+      const result = await packager.packAsync(localBuildFolder, packageInfo, nupkgPath);
+      logger?.info(`Package created successfully: ${result.outputPath}`);
+      return result.outputPath;
+    } finally {
+      try {
+        await this.fileSystem.rm(localBuildFolder);
+      } catch (cleanupError) {
+        logger?.error(`Failed to cleanup build folder: ${cleanupError instanceof Error ? cleanupError.message : String(cleanupError)}`);
+      }
+    }
+  }
+  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 operateModel = {
+      projectId: await ensureWebAppProjectId(this.fileSystem, projectPath),
+      main: mainRelativeToContent,
+      contentType: ProjectTypes2.WebApp,
+      targetFramework: TargetFramework2.Portable,
+      targetRuntime: TARGET_JS_RUNTIME,
+      runtimeOptions: {
+        requiresUserInteraction: false,
+        isAttended: false
+      }
+    };
+    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 manifestExists = await this.fileSystem.exists(manifestSourcePath);
+    if (manifestExists) {
+      const manifestContent = await this.fileSystem.readFile(manifestSourcePath);
+      if (manifestContent) {
+        await this.fileSystem.writeFile(manifestDestPath, manifestContent);
+      }
+    }
+    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);
+      if (uipathJsonContent) {
+        await this.fileSystem.writeFile(uipathJsonDestPath, uipathJsonContent);
+      }
+    }
+    const bindingsPath = Path4.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 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");
+    let entryPointsContent;
+    const projectEntryPointsExists = await this.fileSystem.exists(projectEntryPointsPath);
+    if (projectEntryPointsExists) {
+      const entryPointsData = await this.fileSystem.readFile(projectEntryPointsPath);
+      if (entryPointsData) {
+        entryPointsContent = new TextDecoder().decode(entryPointsData);
+      } else {
+        entryPointsContent = this.createDefaultEntryPoints(mainRelativeToContent);
+      }
+    } else {
+      entryPointsContent = this.createDefaultEntryPoints(mainRelativeToContent);
+    }
+    await this.fileSystem.writeFile(entryPointsPath, entryPointsContent);
+    const packageDescriptorPath = Path4.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")
+      }
+    };
+    const packageDescriptorJson = JSON.stringify(packageDescriptor, null, 2);
+    await this.fileSystem.writeFile(packageDescriptorPath, packageDescriptorJson);
+  }
+  createDefaultEntryPoints(mainFilePath) {
+    const uniqueId = this.generateUniqueId();
+    const entryPoints = {
+      $schema: "https://cloud.uipath.com/draft/2024-12/entry-point",
+      $id: "entry-points-doc-001",
+      entryPoints: [
+        {
+          filePath: mainFilePath,
+          uniqueId,
+          type: DEFAULT_ENTRY_POINT_TYPE,
+          input: {
+            amount: { type: "integer" },
+            id: { type: "string" }
+          },
+          output: {
+            status: { type: "string" }
+          }
+        }
+      ]
+    };
+    return JSON.stringify(entryPoints, null, 2);
+  }
+  generateUniqueId() {
+    const randomBytes = new Uint8Array(16);
+    if (typeof crypto !== "undefined" && crypto.getRandomValues) {
+      crypto.getRandomValues(randomBytes);
+    } else {
+      throw new Error("crypto.getRandomValues is not available");
+    }
+    randomBytes[6] = randomBytes[6] & 15 | 64;
+    randomBytes[8] = randomBytes[8] & 63 | 128;
+    const hex = Array.from(randomBytes).map((b) => b.toString(16).padStart(2, "0")).join("");
+    return [
+      hex.substring(0, 8),
+      hex.substring(8, 12),
+      hex.substring(12, 16),
+      hex.substring(16, 20),
+      hex.substring(20, 32)
+    ].join("-");
+  }
+}
+
+// src/strategies/variant-strategy-factory.ts
+class VariantStrategyFactory {
+  static createStrategy(manifest, fileSystem) {
+    const variant = manifest.type;
+    switch (variant) {
+      case "Coded" /* Coded */:
+        return new CodedAppStrategy(fileSystem);
+      case "JS" /* JS */:
+        return new JsAppsStrategy(fileSystem);
+      default:
+        throw new Error(`Unknown WebApp variant: ${manifest.type}. Supported variants: ${Object.values(WebAppVariantType).join(", ")}`);
+    }
+  }
+}
+
+// src/webapp-tool.ts
+class WebAppTool extends ProjectTool {
+  _temporaryStorage;
+  _tempBuildFolder = null;
+  constructor(fileSystem, logger) {
+    super(fileSystem, logger);
+    this._temporaryStorage = new TemporaryStorageService(fileSystem);
+  }
+  async restoreAsync(_options, _cancellationToken) {
+    this.logger.info("Restore operation is not required for WebApp projects");
+    return ToolResult.success();
+  }
+  async validateAsync(options, _cancellationToken) {
+    if (!options.projectPath) {
+      return this.handleError(new Error(ERROR_MESSAGES.PROJECT_PATH_REQUIRED), "Validation");
+    }
+    try {
+      this.logger.info("Validating WebApp project...");
+      let manifest;
+      let strategy;
+      try {
+        const prepared = await this.getManifestAndStrategy(options.projectPath);
+        manifest = prepared.manifest;
+        strategy = prepared.strategy;
+      } catch (error) {
+        return this.handleError(error, "Validation");
+      }
+      try {
+        if (strategy.validateAsync) {
+          await strategy.validateAsync({
+            fileSystem: this.fileSystem,
+            projectPath: options.projectPath,
+            manifest,
+            logger: this.createStrategyLogger()
+          });
+        }
+      } catch (error) {
+        return this.handleError(error, "Validation");
+      }
+      this.logger.info("WebApp project validation completed");
+      return ToolResult.success();
+    } catch (error) {
+      return this.handleError(error, "Validation");
+    }
+  }
+  async buildAsync(_options, _cancellationToken) {
+    this.logger.info("Build operation for WebApp is lightweight (metadata preparation only)");
+    return ToolResult.success();
+  }
+  async packAsync(options, _cancellationToken) {
+    if (!options.projectPath) {
+      return this.handleError(new Error(ERROR_MESSAGES.PROJECT_PATH_REQUIRED), "Packing");
+    }
+    if (!options.outputPath) {
+      return this.handleError(new Error(ERROR_MESSAGES.OUTPUT_PATH_REQUIRED), "Packing");
+    }
+    if (!options.package?.id) {
+      return this.handleError(new Error(ERROR_MESSAGES.PACKAGE_NAME_REQUIRED), "Packing");
+    }
+    if (!options.package?.version) {
+      return this.handleError(new Error(ERROR_MESSAGES.PACKAGE_VERSION_REQUIRED), "Packing");
+    }
+    try {
+      this.logger.info(`Packing WebApp project: ${options.package.id}@${options.package.version}`);
+      let manifest;
+      let strategy;
+      try {
+        const prepared = await this.getManifestAndStrategy(options.projectPath);
+        manifest = prepared.manifest;
+        strategy = prepared.strategy;
+      } catch (error) {
+        return this.handleError(error, `Packing WebApp project '${options.package.id}'`);
+      }
+      const nupkgPath = await strategy.packageAsync({
+        fileSystem: this.fileSystem,
+        projectPath: options.projectPath,
+        manifest,
+        outputPath: options.outputPath,
+        packageInfo: options.package,
+        logger: this.createStrategyLogger()
+      });
+      this.logger.info(`WebApp package created successfully: ${nupkgPath}`);
+      return new ToolResult(ToolErrorCodes.Success, "done", [nupkgPath]);
+    } catch (error) {
+      return this.handleError(error, `Packing WebApp project '${options.package.id}'`);
+    }
+  }
+  async dispose() {
+    this.logger.info("Disposing WebApp Tool");
+    try {
+      if (this._tempBuildFolder) {
+        await this.fileSystem.rm(this._tempBuildFolder);
+        this._tempBuildFolder = null;
+      }
+      await this._temporaryStorage.cleanup();
+    } catch {}
+  }
+  async getManifestAndStrategy(projectPath) {
+    const manifestPath = Path5.join(projectPath, WEBAPP_MANIFEST_FILE_NAME);
+    const manifestExists = await this.fileSystem.exists(manifestPath);
+    if (!manifestExists) {
+      throw new Error(ERROR_MESSAGES.MANIFEST_NOT_FOUND(WEBAPP_MANIFEST_FILE_NAME));
+    }
+    const projectJsonPath = Path5.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);
+    if (!manifest) {
+      throw new Error(ERROR_MESSAGES.MANIFEST_LOAD_FAILED(WEBAPP_MANIFEST_FILE_NAME));
+    }
+    const strategy = VariantStrategyFactory.createStrategy(manifest, this.fileSystem);
+    return { manifest, strategy };
+  }
+  handleError(error, context) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    this.logger.error(`${context}: ${errorMessage}`);
+    let userMessage;
+    if (context === "Validation") {
+      userMessage = ERROR_MESSAGES.VALIDATION_FAILED(errorMessage);
+    } else if (context.startsWith("Packing")) {
+      userMessage = ERROR_MESSAGES.PACKING_FAILED(errorMessage);
+    } else {
+      userMessage = errorMessage;
+    }
+    return ToolResult.error(ToolErrorCodes.InternalError, userMessage);
+  }
+  createStrategyLogger() {
+    return {
+      info: (msg) => this.logger.info(msg),
+      error: (msg) => this.logger.error(msg),
+      progress: (msg) => this.logger.progress(msg),
+      warn: (msg) => this.logger.warn(msg)
+    };
+  }
+}
+
+// src/webapp-tool-factory.ts
+class WebAppToolFactory {
+  supportedTypes = [ProjectTypes3.AppV2];
+  async createAsync(logger, fileSystem) {
+    return new WebAppTool(fileSystem, logger);
+  }
+}
+
+// src/action-schema/webapp-contributing-tool-factory.ts
+class WebAppContributingToolFactory extends WebAppToolFactory {
+  async describeResourcesAsync(projectDir, fs) {
+    return describeActionApp(projectDir, fs);
+  }
+}
+export {
+  ACTION_SCHEMA_FILE_NAME,
+  JsonActionSchemaValidator,
+  JsonDataType,
+  JsonFormatType,
+  JsonSchemaPropertySchema,
+  VBDataType,
+  VbArgumentCollectionType,
+  VbArgumentDataTypeNamespace,
+  WEBAPP_MANIFEST_FILE_NAME,
+  WebAppContributingToolFactory,
+  describeActionApp,
+  isActionApp,
+  loadWebAppManifest,
+  parseActionSchema
+};
+
+//# debugId=891902301953E23F64756E2164756E21

package/dist/action-schema/manifest-helpers.d.ts

@@ -0,0 +1,45 @@
+import type { IFileSystem } from "@uipath/solutionpackager-tool-core";
+import { WEBAPP_MANIFEST_FILE_NAME, type WebAppManifest } from "../models/webapp-manifest.js";
+/**
+ * Well-known file names owned by the AppV2 domain. `WEBAPP_MANIFEST_FILE_NAME`
+ * is re-exported from the models module so consumers of `/action-schema`
+ * don't need to reach into the root barrel too.
+ */
+export declare const ACTION_SCHEMA_FILE_NAME = "action-schema.json";
+export { WEBAPP_MANIFEST_FILE_NAME };
+/**
+ * `missing` and `invalid` are kept apart on purpose: a folder with no manifest
+ * is a legacy coded app and packs as `Coded`, but a manifest that is there and
+ * cannot be read is the user's file to fix — treating it as `Coded` would
+ * silently turn a Coded Action back into a plain app.
+ */
+export type WebAppManifestLoad = {
+    state: "missing";
+} | {
+    state: "ok";
+    manifest: WebAppManifest;
+} | {
+    state: "invalid";
+    reason: string;
+};
+/**
+ * Reads straight through `readFile` rather than probing with `exists()`
+ * first: `exists()` answers `false` for a file the process may not read, which
+ * would report an EACCES manifest as absent. `@uipath/filesystem` resolves a
+ * missing file to `null` and throws for every other failure.
+ */
+export declare function loadWebAppManifest(fs: IFileSystem, projectDir: string): Promise<WebAppManifestLoad>;
+/**
+ * An app is an action app when its manifest says so either way:
+ * `solutionResourceSubType` is the Solutions registration (what `codedapp
+ * push` and Studio Web read), `config.isActionApp` the packer's flag. `codedapp
+ * init` writes both; an older or hand-edited manifest may carry only one.
+ * A `null` manifest resolves to `false` so callers can compose this with a
+ * `missing` load without a separate branch.
+ */
+export declare function isActionApp(manifest: WebAppManifest | null): boolean;
+/**
+ * The `appV2_<subType>` template row this project's resources come from. A
+ * folder with no manifest is a legacy standalone coded app.
+ */
+export declare function appSubTypeFor(manifest: WebAppManifest | null): string;

package/dist/action-schema/parse.d.ts

@@ -0,0 +1,8 @@
+import { type ParsedActionSchema } from "./types.js";
+/**
+ * Every generated `key` / `id` is derived from the property's schema path
+ * (not `crypto.randomUUID`) — the reconcile idempotency check and the BPMN
+ * bindings that pin to those keys both depend on the same input producing
+ * the same output. Throws on JSON / Zod / unsupported-type failures.
+ */
+export declare function parseActionSchema(raw: string): ParsedActionSchema;

package/dist/action-schema/types.d.ts

@@ -0,0 +1,94 @@
+import { z } from "zod";
+/**
+ * AppV2 CodedAction schema types.
+ *
+ * Lives here (packager-tool-webapp) rather than in a `*-sdk` because the shape
+ * is one project subtype's file format — see AGENTS.md Hard Rule #19. Both
+ * `codedapp-tool` (cloud push) and `solution-tool`'s read-time enhancer
+ * wiring import from here.
+ *
+ * `ContentValidationData` names a Document Understanding contract type. It
+ * belongs at the layer that owns the AppV2 file format, not one below.
+ */
+export declare enum JsonDataType {
+    string = "string",
+    integer = "integer",
+    number = "number",
+    boolean = "boolean",
+    array = "array",
+    object = "object",
+    file = "file",
+    ContentValidationData = "ContentValidationData"
+}
+export declare enum JsonFormatType {
+    uuid = "uuid",
+    date = "date"
+}
+export declare enum VbArgumentCollectionType {
+    array = "Array"
+}
+export declare enum VbArgumentDataTypeNamespace {
+    system = "system"
+}
+export declare enum VBDataType {
+    string = "System.String",
+    int64 = "System.Int64",
+    boolean = "System.Boolean",
+    decimal = "System.Decimal",
+    dateOnly = "System.DateOnly",
+    guid = "System.Guid",
+    object = "System.Object",
+    iresource = "UiPath.Platform.ResourceHandling.IResource",
+    ContentValidationData = "UiPath.DocumentProcessing.Contracts.Actions.ContentValidationData"
+}
+export type JsonSchemaProperty = {
+    type: JsonDataType;
+    required?: boolean;
+    description?: string;
+    format?: JsonFormatType;
+    items?: JsonSchemaProperty;
+    properties?: Record<string, JsonSchemaProperty>;
+};
+export declare const JsonSchemaPropertySchema: z.ZodType<JsonSchemaProperty>;
+export declare const JsonActionSchemaValidator: z.ZodObject<{
+    inputs: z.ZodObject<{
+        type: z.ZodLiteral<"object">;
+        properties: z.ZodRecord<z.ZodString, z.ZodType<JsonSchemaProperty, unknown, z.core.$ZodTypeInternals<JsonSchemaProperty, unknown>>>;
+    }, z.core.$strip>;
+    outputs: z.ZodObject<{
+        type: z.ZodLiteral<"object">;
+        properties: z.ZodRecord<z.ZodString, z.ZodType<JsonSchemaProperty, unknown, z.core.$ZodTypeInternals<JsonSchemaProperty, unknown>>>;
+    }, z.core.$strip>;
+    inOuts: z.ZodObject<{
+        type: z.ZodLiteral<"object">;
+        properties: z.ZodRecord<z.ZodString, z.ZodType<JsonSchemaProperty, unknown, z.core.$ZodTypeInternals<JsonSchemaProperty, unknown>>>;
+    }, z.core.$strip>;
+    outcomes: z.ZodObject<{
+        type: z.ZodLiteral<"object">;
+        properties: z.ZodRecord<z.ZodString, z.ZodDefault<z.ZodOptional<z.ZodObject<{}, z.core.$loose>>>>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type JsonActionSchema = z.infer<typeof JsonActionSchemaValidator>;
+export type ParsedActionPropertySchema = {
+    key: string;
+    name: string;
+    type: VBDataType;
+    isList: boolean;
+    typeNamespace: VbArgumentDataTypeNamespace;
+    version: number;
+    required: boolean;
+    properties?: ParsedActionPropertySchema[];
+    collectionDataType?: VbArgumentCollectionType | null;
+    description?: string;
+};
+export interface ParsedActionSchema {
+    id: string;
+    name: string;
+    key: string;
+    description: string;
+    inputs: ParsedActionPropertySchema[];
+    outputs: ParsedActionPropertySchema[];
+    inOuts: ParsedActionPropertySchema[];
+    outcomes: ParsedActionPropertySchema[];
+    version: number;
+}

package/dist/action-schema/webapp-contributing-tool-factory.d.ts

@@ -0,0 +1,17 @@
+import type { IFileSystem, ProjectResourceContribution } from "@uipath/solutionpackager-tool-core";
+import { WebAppToolFactory } from "../webapp-tool-factory.js";
+/**
+ * `WebAppToolFactory` plus the AppV2 resource contribution.
+ *
+ * Lives in the node-target `./action-schema` subpath, not in the browser-built
+ * `.` barrel: `src/index.ts` builds `--target browser` with no `--splitting`,
+ * so even a lazy `import()` from there would land *in* the browser bundle
+ * instead of beside it. `codedapp-tool/src/packager-tool.ts` is node-only and
+ * registers this subclass; the browser entry keeps the plain factory.
+ *
+ * `supportedTypes` is inherited unchanged — `ToolsFactoryRepository` keys
+ * dispatch on it, and the first factory registered for a type wins.
+ */
+export declare class WebAppContributingToolFactory extends WebAppToolFactory {
+    describeResourcesAsync(projectDir: string, fs: IFileSystem): Promise<ProjectResourceContribution>;
+}

package/package.json

@@ -1,10 +1,11 @@
 {
     "name": "@uipath/packager-tool-webapp",
-    "version": "1.202.0-preview.159",
+    "version": "1.203.0-preview.160",
     "description": "UiPath WebApp tool implementation",
     "type": "module",
     "exports": {
-        ".": "./dist/index.js"
+        ".": "./dist/index.js",
+        "./action-schema": "./dist/action-schema/index.js"
     },
     "repository": {
         "type": "git",
@@ -18,10 +19,12 @@
     "files": [
         "dist"
     ],
-    "author": "",
+    "author": "UiPath",
     "license": "SEE LICENSE IN LICENSE.txt",
     "peerDependencies": {
-        "@uipath/solutionpackager-tool-core": "1.202.0"
+        "@uipath/common": "1.203.0",
+        "@uipath/solutionpackager-tool-core": "1.203.0",
+        "zod": "^4.3.6"
     },
-    "gitHead": "a3f23209784c6cec7155e735fa051b48ca49e8d7"
+    "gitHead": "3a42062ba731afca4595ba9aa8a80afc9667528d"
 }