mobbdev 1.4.35 → 1.4.36

package/dist/index.mjs

@@ -1377,26 +1377,26 @@ var init_getIssueType = __esm({
 });
 
 // src/features/analysis/scm/shared/src/types/shared.ts
-import { z as z5 } from "zod";
+import { z as z2 } from "zod";
 var ParsedSeverityZ, ScmSubmitFixRequestsZ;
 var init_shared = __esm({
   "src/features/analysis/scm/shared/src/types/shared.ts"() {
     "use strict";
     init_client_generates();
-    ParsedSeverityZ = z5.nativeEnum(Vulnerability_Severity_Enum).nullish().transform((i) => i ?? "low" /* Low */);
-    ScmSubmitFixRequestsZ = z5.array(
-      z5.object({
-        scmSubmitFixRequest: z5.object({
-          submitFixRequest: z5.object({
-            createdByUser: z5.object({
-              email: z5.string()
+    ParsedSeverityZ = z2.nativeEnum(Vulnerability_Severity_Enum).nullish().transform((i) => i ?? "low" /* Low */);
+    ScmSubmitFixRequestsZ = z2.array(
+      z2.object({
+        scmSubmitFixRequest: z2.object({
+          submitFixRequest: z2.object({
+            createdByUser: z2.object({
+              email: z2.string()
             }),
-            targetBranchName: z5.string().default("")
+            targetBranchName: z2.string().default("")
           }),
-          prUrl: z5.string().nullable(),
-          prStatus: z5.nativeEnum(Pr_Status_Enum).nullable(),
-          commitUrl: z5.string().nullable(),
-          scmId: z5.string()
+          prUrl: z2.string().nullable(),
+          prStatus: z2.nativeEnum(Pr_Status_Enum).nullable(),
+          commitUrl: z2.string().nullable(),
+          scmId: z2.string()
         })
       })
     );
@@ -1404,105 +1404,106 @@ var init_shared = __esm({
 });
 
 // src/features/analysis/scm/shared/src/types/fix.ts
-import { z as z6 } from "zod";
+import { z as z3 } from "zod";
 var PackageInfoZ, ManifestActionRequiredZ, ExtraContextInternalZ, FixExtraContextZ, PatchAndQuestionsZ, FixRatingZ, IssueRatingZ, IssueSharedStateZ, FixSharedStateZ, FixQueryZ, FixPartsForFixScreenZ;
 var init_fix = __esm({
   "src/features/analysis/scm/shared/src/types/fix.ts"() {
     "use strict";
     init_client_generates();
     init_shared();
-    PackageInfoZ = z6.object({
-      name: z6.string(),
-      version: z6.string(),
-      envName: z6.string().nullable()
-    });
-    ManifestActionRequiredZ = z6.object({
-      action: z6.nativeEnum(ManifestAction),
-      language: z6.nativeEnum(Language),
+    PackageInfoZ = z3.object({
+      name: z3.string(),
+      version: z3.string(),
+      envName: z3.string().nullable()
+    });
+    ManifestActionRequiredZ = z3.object({
+      action: z3.nativeEnum(ManifestAction),
+      language: z3.nativeEnum(Language),
       lib: PackageInfoZ,
       typesLib: PackageInfoZ.nullable()
     });
-    ExtraContextInternalZ = z6.object({
-      key: z6.string(),
-      value: z6.string().or(z6.boolean()).or(
-        z6.object({
-          int: z6.boolean(),
-          integer: z6.boolean(),
-          string: z6.boolean(),
-          date: z6.boolean()
+    ExtraContextInternalZ = z3.object({
+      key: z3.string(),
+      value: z3.string().or(z3.boolean()).or(
+        z3.object({
+          int: z3.boolean(),
+          integer: z3.boolean(),
+          string: z3.boolean(),
+          date: z3.boolean()
         })
       )
     });
-    FixExtraContextZ = z6.object({
-      fixDescription: z6.string(),
-      manifestActionsRequired: z6.array(ManifestActionRequiredZ),
-      extraContext: z6.array(ExtraContextInternalZ),
-      // E-2015 PR5c: analyzer-served fix-level guidance. default([]) so a query that
+    FixExtraContextZ = z3.object({
+      fixDescription: z3.string(),
+      manifestActionsRequired: z3.array(ManifestActionRequiredZ),
+      extraContext: z3.array(ExtraContextInternalZ),
+      // E-2015: analyzer-served fix-level guidance. default([]) so a query that
       // omits it still parses, while the output type is a required string[] to match
-      // the non-null GraphQL field. getFixGuidances prefers served then falls back.
-      guidances: z6.array(z6.string()).default([])
-    });
-    PatchAndQuestionsZ = z6.object({
-      __typename: z6.literal("FixData"),
-      patch: z6.string(),
-      patchOriginalEncodingBase64: z6.string(),
-      questions: z6.array(
-        z6.object({
-          name: z6.string(),
-          key: z6.string(),
-          index: z6.number(),
-          defaultValue: z6.string(),
-          value: z6.string().nullable(),
-          extraContext: z6.array(ExtraContextInternalZ),
-          inputType: z6.nativeEnum(FixQuestionInputType),
-          options: z6.array(z6.string()),
-          // E-2015 PR5: analyzer-served question copy. default('') so a query that
-          // omits these still parses (-> '' -> FE falls back to its own copy), while
-          // the output type stays a required `string` to match the non-null GraphQL
-          // fields. Consumers use `served || storedQuestionData`.
-          content: z6.string().default(""),
-          description: z6.string().default(""),
-          guidance: z6.string().default("")
+      // the non-null GraphQL field. The analyzer is the sole source; getFixGuidances
+      // uses the served value directly (no fallback).
+      guidances: z3.array(z3.string()).default([])
+    });
+    PatchAndQuestionsZ = z3.object({
+      __typename: z3.literal("FixData"),
+      patch: z3.string(),
+      patchOriginalEncodingBase64: z3.string(),
+      questions: z3.array(
+        z3.object({
+          name: z3.string(),
+          key: z3.string(),
+          index: z3.number(),
+          defaultValue: z3.string(),
+          value: z3.string().nullable(),
+          extraContext: z3.array(ExtraContextInternalZ),
+          inputType: z3.nativeEnum(FixQuestionInputType),
+          options: z3.array(z3.string()),
+          // E-2015: analyzer-served question text. default('') so a query that
+          // omits these still parses (-> ''), while the output type stays a required
+          // `string` to match the non-null GraphQL fields. The analyzer is the sole
+          // source; consumers use the served value directly (no fallback).
+          content: z3.string().default(""),
+          description: z3.string().default(""),
+          guidance: z3.string().default("")
         })
       ),
       extraContext: FixExtraContextZ
     });
-    FixRatingZ = z6.object({
-      voteScore: z6.number(),
-      fixRatingTag: z6.nativeEnum(Fix_Rating_Tag_Enum).nullable().default(null),
-      comment: z6.string().nullable().default(null),
-      updatedDate: z6.string().nullable(),
-      user: z6.object({
-        email: z6.string(),
-        name: z6.string()
+    FixRatingZ = z3.object({
+      voteScore: z3.number(),
+      fixRatingTag: z3.nativeEnum(Fix_Rating_Tag_Enum).nullable().default(null),
+      comment: z3.string().nullable().default(null),
+      updatedDate: z3.string().nullable(),
+      user: z3.object({
+        email: z3.string(),
+        name: z3.string()
       })
     });
-    IssueRatingZ = z6.object({
-      voteScore: z6.number(),
-      comment: z6.string().nullable().default(null),
-      updatedDate: z6.string().nullable(),
-      user: z6.object({
-        email: z6.string(),
-        name: z6.string()
+    IssueRatingZ = z3.object({
+      voteScore: z3.number(),
+      comment: z3.string().nullable().default(null),
+      updatedDate: z3.string().nullable(),
+      user: z3.object({
+        email: z3.string(),
+        name: z3.string()
       })
     });
-    IssueSharedStateZ = z6.object({
-      id: z6.string(),
-      createdAt: z6.string(),
-      isArchived: z6.boolean(),
-      ticketIntegrationId: z6.string().nullable(),
-      ticketIntegrations: z6.array(
-        z6.object({
-          url: z6.string()
+    IssueSharedStateZ = z3.object({
+      id: z3.string(),
+      createdAt: z3.string(),
+      isArchived: z3.boolean(),
+      ticketIntegrationId: z3.string().nullable(),
+      ticketIntegrations: z3.array(
+        z3.object({
+          url: z3.string()
         })
       ),
-      issueRatings: z6.array(IssueRatingZ).default([])
+      issueRatings: z3.array(IssueRatingZ).default([])
     }).nullable();
-    FixSharedStateZ = z6.object({
-      state: z6.nativeEnum(Fix_State_Enum),
-      isArchived: z6.boolean(),
+    FixSharedStateZ = z3.object({
+      state: z3.nativeEnum(Fix_State_Enum),
+      isArchived: z3.boolean(),
       scmSubmitFixRequests: ScmSubmitFixRequestsZ,
-      fixRatings: z6.array(FixRatingZ).default([])
+      fixRatings: z3.array(FixRatingZ).default([])
     }).nullish().transform(
       (data) => data ? data : {
         state: "Ready" /* Ready */,
@@ -1511,46 +1512,46 @@ var init_fix = __esm({
         fixRatings: []
       }
     );
-    FixQueryZ = z6.object({
-      __typename: z6.literal("fix").optional(),
-      id: z6.string().uuid(),
+    FixQueryZ = z3.object({
+      __typename: z3.literal("fix").optional(),
+      id: z3.string().uuid(),
       sharedState: FixSharedStateZ,
-      modifiedBy: z6.string().nullable(),
-      gitBlameLogin: z6.string().nullable(),
-      safeIssueLanguage: z6.string(),
-      safeIssueType: z6.string(),
-      confidence: z6.number(),
-      fixReportId: z6.string().uuid(),
-      isExpired: z6.boolean().default(false),
-      fixFiles: z6.array(
-        z6.object({
-          fileRepoRelativePath: z6.string()
+      modifiedBy: z3.string().nullable(),
+      gitBlameLogin: z3.string().nullable(),
+      safeIssueLanguage: z3.string(),
+      safeIssueType: z3.string(),
+      confidence: z3.number(),
+      fixReportId: z3.string().uuid(),
+      isExpired: z3.boolean().default(false),
+      fixFiles: z3.array(
+        z3.object({
+          fileRepoRelativePath: z3.string()
         })
       ),
-      numberOfVulnerabilityIssues: z6.number(),
-      severityText: z6.nativeEnum(Vulnerability_Severity_Enum),
-      vulnerabilityReportIssues: z6.array(
-        z6.object({
-          vendorIssueId: z6.string(),
-          issueLanguage: z6.string(),
+      numberOfVulnerabilityIssues: z3.number(),
+      severityText: z3.nativeEnum(Vulnerability_Severity_Enum),
+      vulnerabilityReportIssues: z3.array(
+        z3.object({
+          vendorIssueId: z3.string(),
+          issueLanguage: z3.string(),
           parsedSeverity: ParsedSeverityZ,
-          sharedState: z6.object({
-            id: z6.string().uuid(),
-            isArchived: z6.boolean(),
-            ticketIntegrationId: z6.string().uuid().nullable()
+          sharedState: z3.object({
+            id: z3.string().uuid(),
+            isArchived: z3.boolean(),
+            ticketIntegrationId: z3.string().uuid().nullable()
           }).nullable()
         })
       ),
       patchAndQuestions: PatchAndQuestionsZ,
-      effortToApplyFix: z6.nativeEnum(Effort_To_Apply_Fix_Enum).nullable()
+      effortToApplyFix: z3.nativeEnum(Effort_To_Apply_Fix_Enum).nullable()
     });
     FixPartsForFixScreenZ = FixQueryZ.merge(
-      z6.object({
-        vulnerabilityReportIssues: z6.array(
-          z6.object({
-            vendorIssueId: z6.string(),
-            issueType: z6.string(),
-            issueLanguage: z6.string(),
+      z3.object({
+        vulnerabilityReportIssues: z3.array(
+          z3.object({
+            vendorIssueId: z3.string(),
+            issueType: z3.string(),
+            issueLanguage: z3.string(),
             sharedState: IssueSharedStateZ
           })
         )
@@ -1560,24 +1561,24 @@ var init_fix = __esm({
 });
 
 // src/features/analysis/scm/shared/src/types/analysis.ts
-import { z as z7 } from "zod";
+import { z as z4 } from "zod";
 var FixPageFixReportZ;
 var init_analysis = __esm({
   "src/features/analysis/scm/shared/src/types/analysis.ts"() {
     "use strict";
     init_client_generates();
     init_client_generates();
-    FixPageFixReportZ = z7.object({
-      id: z7.string().uuid(),
-      analysisUrl: z7.string(),
-      createdOn: z7.string(),
-      state: z7.nativeEnum(Fix_Report_State_Enum),
-      repo: z7.object({
-        name: z7.string().nullable(),
-        originalUrl: z7.string(),
-        reference: z7.string(),
-        commitSha: z7.string(),
-        isKnownBranch: z7.boolean().nullish().default(true)
+    FixPageFixReportZ = z4.object({
+      id: z4.string().uuid(),
+      analysisUrl: z4.string(),
+      createdOn: z4.string(),
+      state: z4.nativeEnum(Fix_Report_State_Enum),
+      repo: z4.object({
+        name: z4.string().nullable(),
+        originalUrl: z4.string(),
+        reference: z4.string(),
+        commitSha: z4.string(),
+        isKnownBranch: z4.boolean().nullish().default(true)
       }).nullable().transform(
         (repo) => repo ?? {
           name: null,
@@ -1587,13 +1588,13 @@ var init_analysis = __esm({
           isKnownBranch: true
         }
       ),
-      vulnerabilityReport: z7.object({
-        id: z7.string().uuid(),
-        vendor: z7.nativeEnum(Vulnerability_Report_Vendor_Enum),
-        computedVendor: z7.nativeEnum(Vulnerability_Report_Vendor_Enum),
-        projectId: z7.string().uuid(),
-        project: z7.object({
-          organizationId: z7.string().uuid()
+      vulnerabilityReport: z4.object({
+        id: z4.string().uuid(),
+        vendor: z4.nativeEnum(Vulnerability_Report_Vendor_Enum),
+        computedVendor: z4.nativeEnum(Vulnerability_Report_Vendor_Enum),
+        projectId: z4.string().uuid(),
+        project: z4.object({
+          organizationId: z4.string().uuid()
         })
       })
     });
@@ -1601,7 +1602,7 @@ var init_analysis = __esm({
 });
 
 // src/features/analysis/scm/shared/src/types/issue.ts
-import { z as z8 } from "zod";
+import { z as z5 } from "zod";
 var MAX_SOURCE_CODE_FILE_SIZE_IN_BYTES, VulnerabilityReportIssueRatingZ, VulnerabilityReportIssueSharedStateZ, BaseIssuePartsZ, FalsePositivePartsZ, UnfixablePartsZ, IssuePartsWithFixZ, IssuePartsFpZ, GeneralIssueZ, IssuePartsZ, GetIssueIndexesZ, GetIssueScreenDataZ, IssueBucketZ, mapCategoryToBucket, mapBucketTypeToCategory;
 var init_issue = __esm({
   "src/features/analysis/scm/shared/src/types/issue.ts"() {
@@ -1611,57 +1612,57 @@ var init_issue = __esm({
     init_fix();
     init_shared();
     MAX_SOURCE_CODE_FILE_SIZE_IN_BYTES = 1e5;
-    VulnerabilityReportIssueRatingZ = z8.object({
-      voteScore: z8.number(),
-      comment: z8.string().nullable().default(null),
-      updatedDate: z8.string().nullable(),
-      user: z8.object({
-        email: z8.string(),
-        name: z8.string()
+    VulnerabilityReportIssueRatingZ = z5.object({
+      voteScore: z5.number(),
+      comment: z5.string().nullable().default(null),
+      updatedDate: z5.string().nullable(),
+      user: z5.object({
+        email: z5.string(),
+        name: z5.string()
       })
     });
-    VulnerabilityReportIssueSharedStateZ = z8.object({
-      id: z8.string().uuid(),
-      createdAt: z8.string(),
-      isArchived: z8.boolean(),
-      ticketIntegrationId: z8.string().uuid().nullable(),
-      ticketIntegrations: z8.array(
-        z8.object({
-          url: z8.string()
+    VulnerabilityReportIssueSharedStateZ = z5.object({
+      id: z5.string().uuid(),
+      createdAt: z5.string(),
+      isArchived: z5.boolean(),
+      ticketIntegrationId: z5.string().uuid().nullable(),
+      ticketIntegrations: z5.array(
+        z5.object({
+          url: z5.string()
         })
       ),
-      issueRatings: z8.array(VulnerabilityReportIssueRatingZ).default([])
+      issueRatings: z5.array(VulnerabilityReportIssueRatingZ).default([])
     }).nullish();
-    BaseIssuePartsZ = z8.object({
-      id: z8.string().uuid(),
-      safeIssueType: z8.string(),
-      safeIssueLanguage: z8.string(),
-      createdAt: z8.string(),
+    BaseIssuePartsZ = z5.object({
+      id: z5.string().uuid(),
+      safeIssueType: z5.string(),
+      safeIssueLanguage: z5.string(),
+      createdAt: z5.string(),
       parsedSeverity: ParsedSeverityZ,
-      category: z8.nativeEnum(Vulnerability_Report_Issue_Category_Enum),
-      extraData: z8.object({
-        missing_files: z8.string().array().nullish(),
-        error_files: z8.string().array().nullish(),
-        ai_cost_limit_exceeded: z8.string().nullish()
+      category: z5.nativeEnum(Vulnerability_Report_Issue_Category_Enum),
+      extraData: z5.object({
+        missing_files: z5.string().array().nullish(),
+        error_files: z5.string().array().nullish(),
+        ai_cost_limit_exceeded: z5.string().nullish()
       }),
-      vulnerabilityReportIssueTags: z8.array(
-        z8.object({
-          tag: z8.nativeEnum(Vulnerability_Report_Issue_Tag_Enum)
+      vulnerabilityReportIssueTags: z5.array(
+        z5.object({
+          tag: z5.nativeEnum(Vulnerability_Report_Issue_Tag_Enum)
         })
       ),
-      codeNodes: z8.array(
-        z8.object({
-          path: z8.string(),
-          line: z8.number(),
-          index: z8.number()
+      codeNodes: z5.array(
+        z5.object({
+          path: z5.string(),
+          line: z5.number(),
+          index: z5.number()
         })
       ).transform((nodes) => nodes.sort((a, b) => b.index - a.index)),
-      sourceCodeNodes: z8.array(
-        z8.object({
-          sourceCodeFile: z8.object({
-            path: z8.string(),
-            signedFile: z8.object({
-              url: z8.string()
+      sourceCodeNodes: z5.array(
+        z5.object({
+          sourceCodeFile: z5.object({
+            path: z5.string(),
+            signedFile: z5.object({
+              url: z5.string()
             })
           })
         }).transform(async ({ sourceCodeFile }) => {
@@ -1677,71 +1678,71 @@ var init_issue = __esm({
         })
       ).transform((nodes) => nodes.filter((node) => node !== null)),
       fix: FixPartsForFixScreenZ.nullish(),
-      vulnerabilityReportIssueNodeDiffFile: z8.object({
-        signedFile: z8.object({
-          url: z8.string()
+      vulnerabilityReportIssueNodeDiffFile: z5.object({
+        signedFile: z5.object({
+          url: z5.string()
         }).transform(async ({ url }) => {
           const codeDiff = await fetch(url).then((res) => res.text());
           return { codeDiff };
         })
       }).nullish(),
       sharedState: VulnerabilityReportIssueSharedStateZ,
-      unfixableId: z8.string().uuid().nullish()
+      unfixableId: z5.string().uuid().nullish()
     });
-    FalsePositivePartsZ = z8.object({
-      extraContext: z8.array(z8.object({ key: z8.string(), value: z8.string() })),
-      fixDescription: z8.string()
+    FalsePositivePartsZ = z5.object({
+      extraContext: z5.array(z5.object({ key: z5.string(), value: z5.string() })),
+      fixDescription: z5.string()
     });
-    UnfixablePartsZ = z8.object({
-      extraContext: z8.array(z8.object({ key: z8.string(), value: z8.string() })),
-      fixDescription: z8.string()
+    UnfixablePartsZ = z5.object({
+      extraContext: z5.array(z5.object({ key: z5.string(), value: z5.string() })),
+      fixDescription: z5.string()
     });
     IssuePartsWithFixZ = BaseIssuePartsZ.merge(
-      z8.object({
-        category: z8.literal("Irrelevant" /* Irrelevant */),
+      z5.object({
+        category: z5.literal("Irrelevant" /* Irrelevant */),
         fix: FixPartsForFixScreenZ.nullish()
       })
     );
     IssuePartsFpZ = BaseIssuePartsZ.merge(
-      z8.object({
-        category: z8.literal("FalsePositive" /* FalsePositive */),
-        fpId: z8.string().uuid(),
+      z5.object({
+        category: z5.literal("FalsePositive" /* FalsePositive */),
+        fpId: z5.string().uuid(),
         getFalsePositive: FalsePositivePartsZ
       })
     );
     GeneralIssueZ = BaseIssuePartsZ.merge(
-      z8.object({
-        category: z8.union([
-          z8.literal("NoFix" /* NoFix */),
-          z8.literal("Unsupported" /* Unsupported */),
-          z8.literal("Fixable" /* Fixable */),
-          z8.literal("Filtered" /* Filtered */),
-          z8.literal("Pending" /* Pending */)
+      z5.object({
+        category: z5.union([
+          z5.literal("NoFix" /* NoFix */),
+          z5.literal("Unsupported" /* Unsupported */),
+          z5.literal("Fixable" /* Fixable */),
+          z5.literal("Filtered" /* Filtered */),
+          z5.literal("Pending" /* Pending */)
         ]),
         getUnfixable: UnfixablePartsZ.nullish()
       })
     );
-    IssuePartsZ = z8.union([
+    IssuePartsZ = z5.union([
       IssuePartsFpZ,
       IssuePartsWithFixZ,
       GeneralIssueZ
     ]);
-    GetIssueIndexesZ = z8.object({
-      currentIndex: z8.number(),
-      totalIssues: z8.number(),
-      nextIssue: z8.object({
-        id: z8.string().uuid()
+    GetIssueIndexesZ = z5.object({
+      currentIndex: z5.number(),
+      totalIssues: z5.number(),
+      nextIssue: z5.object({
+        id: z5.string().uuid()
       }).nullish(),
-      prevIssue: z8.object({
-        id: z8.string().uuid()
+      prevIssue: z5.object({
+        id: z5.string().uuid()
       }).nullish()
     });
-    GetIssueScreenDataZ = z8.object({
+    GetIssueScreenDataZ = z5.object({
       fixReport_by_pk: FixPageFixReportZ,
       vulnerability_report_issue_by_pk: IssuePartsZ,
       issueIndexes: GetIssueIndexesZ
     });
-    IssueBucketZ = z8.enum(["fixable", "irrelevant", "remaining"]);
+    IssueBucketZ = z5.enum(["fixable", "irrelevant", "remaining"]);
     mapCategoryToBucket = {
       FalsePositive: "irrelevant",
       Irrelevant: "irrelevant",
@@ -1768,19 +1769,19 @@ var init_issue = __esm({
 });
 
 // src/features/analysis/scm/shared/src/validations.ts
-import { z as z9 } from "zod";
+import { z as z6 } from "zod";
 var IssueTypeSettingZ, IssueTypeSettingsZ;
 var init_validations = __esm({
   "src/features/analysis/scm/shared/src/validations.ts"() {
     "use strict";
     init_getIssueType();
     init_issueTypeCatalog();
-    IssueTypeSettingZ = z9.object({
-      autoPrEnabled: z9.boolean(),
-      enabled: z9.boolean(),
+    IssueTypeSettingZ = z6.object({
+      autoPrEnabled: z6.boolean(),
+      enabled: z6.boolean(),
       issueType: SafeIssueTypeStringZ
     });
-    IssueTypeSettingsZ = z9.array(IssueTypeSettingZ).transform((issueTypeSettings) => {
+    IssueTypeSettingsZ = z6.array(IssueTypeSettingZ).transform((issueTypeSettings) => {
       const catalogValues = listIssueTypeCatalog().map((entry) => entry.value);
       if (catalogValues.length === 0) {
         throw new Error(
@@ -1805,7 +1806,7 @@ var init_validations = __esm({
 });
 
 // src/features/analysis/scm/shared/src/types/types.ts
-import { z as z10 } from "zod";
+import { z as z7 } from "zod";
 var OrganizationScreenQueryParamsZ, ProjectPageQueryParamsZ, AnalysisPageQueryParamsZ, FixPageQueryParamsZ, IssuePageQueryParamsZ, CliLoginPageQueryParamsZ, AnalysisReportDigestedZ, IssueSharedStateZ2, ReportQueryResultZ, ReportFixesQueryFixZ, BaseVulnerabilityReportIssueZ, VulnerabilityReportIssueZ, VulnerabilityReportIssueWithCodeFilePathZ, GetReportIssuesQueryZ, FixReportByProjectZ, FixScreenQueryResultZ, FixPageQueryZ, GetReportFixesQueryZ, GetFixReportStatsQueryZ, ProjectVulnerabilityReport, GetProjectsQueryZ, ProjectPageQueryResultZ, GetProjectMembersDataZ, RepoArgsZ, scmCloudUrl, ScmType, ConvertToSarifInputFileFormat;
 var init_types = __esm({
   "src/features/analysis/scm/shared/src/types/types.ts"() {
@@ -1816,117 +1817,117 @@ var init_types = __esm({
     init_fix();
     init_issue();
     init_shared();
-    OrganizationScreenQueryParamsZ = z10.object({
-      organizationId: z10.string().uuid()
+    OrganizationScreenQueryParamsZ = z7.object({
+      organizationId: z7.string().uuid()
     });
-    ProjectPageQueryParamsZ = z10.object({
-      organizationId: z10.string().uuid(),
-      projectId: z10.string().uuid()
+    ProjectPageQueryParamsZ = z7.object({
+      organizationId: z7.string().uuid(),
+      projectId: z7.string().uuid()
     });
     AnalysisPageQueryParamsZ = ProjectPageQueryParamsZ.extend({
-      reportId: z10.string().uuid()
+      reportId: z7.string().uuid()
     });
     FixPageQueryParamsZ = AnalysisPageQueryParamsZ.extend({
-      fixId: z10.string().uuid()
+      fixId: z7.string().uuid()
     });
     IssuePageQueryParamsZ = AnalysisPageQueryParamsZ.extend({
-      issueId: z10.string().uuid()
-    });
-    CliLoginPageQueryParamsZ = z10.object({
-      loginId: z10.string().uuid()
-    });
-    AnalysisReportDigestedZ = z10.object({
-      id: z10.string().uuid(),
-      state: z10.nativeEnum(Fix_Report_State_Enum),
-      vulnerabilityReport: z10.object({
-        reportSummaryUrl: z10.string().url().nullish(),
-        scanDate: z10.string().nullable(),
-        supported: z10.object({
-          aggregate: z10.object({
-            count: z10.number()
+      issueId: z7.string().uuid()
+    });
+    CliLoginPageQueryParamsZ = z7.object({
+      loginId: z7.string().uuid()
+    });
+    AnalysisReportDigestedZ = z7.object({
+      id: z7.string().uuid(),
+      state: z7.nativeEnum(Fix_Report_State_Enum),
+      vulnerabilityReport: z7.object({
+        reportSummaryUrl: z7.string().url().nullish(),
+        scanDate: z7.string().nullable(),
+        supported: z7.object({
+          aggregate: z7.object({
+            count: z7.number()
           })
         }),
-        all: z10.object({
-          aggregate: z10.object({
-            count: z10.number()
+        all: z7.object({
+          aggregate: z7.object({
+            count: z7.number()
           })
         }),
-        vendor: z10.nativeEnum(Vulnerability_Report_Vendor_Enum),
-        project: z10.object({
-          organizationId: z10.string().uuid()
+        vendor: z7.nativeEnum(Vulnerability_Report_Vendor_Enum),
+        project: z7.object({
+          organizationId: z7.string().uuid()
         })
       })
     });
-    IssueSharedStateZ2 = z10.object({
-      id: z10.string().uuid(),
-      createdAt: z10.string(),
-      isArchived: z10.boolean(),
-      ticketIntegrationId: z10.string().uuid().nullable(),
-      ticketIntegrations: z10.array(
-        z10.object({
-          url: z10.string()
+    IssueSharedStateZ2 = z7.object({
+      id: z7.string().uuid(),
+      createdAt: z7.string(),
+      isArchived: z7.boolean(),
+      ticketIntegrationId: z7.string().uuid().nullable(),
+      ticketIntegrations: z7.array(
+        z7.object({
+          url: z7.string()
         })
       )
     }).nullable();
-    ReportQueryResultZ = z10.object({
-      fixReport_by_pk: z10.object({
-        id: z10.string().uuid(),
-        analysisUrl: z10.string(),
-        fixesCommitted: z10.object({
-          aggregate: z10.object({ count: z10.number() })
+    ReportQueryResultZ = z7.object({
+      fixReport_by_pk: z7.object({
+        id: z7.string().uuid(),
+        analysisUrl: z7.string(),
+        fixesCommitted: z7.object({
+          aggregate: z7.object({ count: z7.number() })
         }),
-        fixesDownloaded: z10.object({
-          aggregate: z10.object({ count: z10.number() })
+        fixesDownloaded: z7.object({
+          aggregate: z7.object({ count: z7.number() })
         }),
-        fixesDoneCount: z10.number(),
-        fixesInprogressCount: z10.number(),
-        fixesReadyCount: z10.object({
-          aggregate: z10.object({ count: z10.number() })
+        fixesDoneCount: z7.number(),
+        fixesInprogressCount: z7.number(),
+        fixesReadyCount: z7.object({
+          aggregate: z7.object({ count: z7.number() })
         }),
-        issueTypes: z10.record(z10.string(), z10.number()).nullable(),
-        issueLanguages: z10.record(z10.string(), z10.number()).nullable(),
-        fixesCountByEffort: z10.record(z10.string(), z10.number()).nullable(),
-        vulnerabilitySeverities: z10.record(z10.string(), z10.number()).nullable(),
-        createdOn: z10.string(),
-        expirationOn: z10.string().nullable(),
-        state: z10.nativeEnum(Fix_Report_State_Enum),
-        failReason: z10.string().nullable(),
-        candidateToRerun: z10.boolean(),
-        fixes: z10.array(
-          z10.object({
-            id: z10.string().uuid(),
-            safeIssueLanguage: z10.string(),
-            safeIssueType: z10.string(),
-            confidence: z10.number(),
-            effortToApplyFix: z10.nativeEnum(Effort_To_Apply_Fix_Enum).nullable(),
-            modifiedBy: z10.string().nullable(),
-            gitBlameLogin: z10.string().nullable(),
-            fixReportId: z10.string().uuid(),
-            filePaths: z10.array(
-              z10.object({
-                fileRepoRelativePath: z10.string()
+        issueTypes: z7.record(z7.string(), z7.number()).nullable(),
+        issueLanguages: z7.record(z7.string(), z7.number()).nullable(),
+        fixesCountByEffort: z7.record(z7.string(), z7.number()).nullable(),
+        vulnerabilitySeverities: z7.record(z7.string(), z7.number()).nullable(),
+        createdOn: z7.string(),
+        expirationOn: z7.string().nullable(),
+        state: z7.nativeEnum(Fix_Report_State_Enum),
+        failReason: z7.string().nullable(),
+        candidateToRerun: z7.boolean(),
+        fixes: z7.array(
+          z7.object({
+            id: z7.string().uuid(),
+            safeIssueLanguage: z7.string(),
+            safeIssueType: z7.string(),
+            confidence: z7.number(),
+            effortToApplyFix: z7.nativeEnum(Effort_To_Apply_Fix_Enum).nullable(),
+            modifiedBy: z7.string().nullable(),
+            gitBlameLogin: z7.string().nullable(),
+            fixReportId: z7.string().uuid(),
+            filePaths: z7.array(
+              z7.object({
+                fileRepoRelativePath: z7.string()
               })
             ),
             sharedState: FixSharedStateZ,
-            numberOfVulnerabilityIssues: z10.number(),
-            severityText: z10.nativeEnum(Vulnerability_Severity_Enum),
-            vulnerabilityReportIssues: z10.array(
-              z10.object({
-                id: z10.string().uuid(),
-                issueType: z10.string(),
-                issueLanguage: z10.string(),
-                category: z10.nativeEnum(Vulnerability_Report_Issue_Category_Enum),
+            numberOfVulnerabilityIssues: z7.number(),
+            severityText: z7.nativeEnum(Vulnerability_Severity_Enum),
+            vulnerabilityReportIssues: z7.array(
+              z7.object({
+                id: z7.string().uuid(),
+                issueType: z7.string(),
+                issueLanguage: z7.string(),
+                category: z7.nativeEnum(Vulnerability_Report_Issue_Category_Enum),
                 sharedState: IssueSharedStateZ2
               })
             )
           })
         ),
-        repo: z10.object({
-          name: z10.string().nullable(),
-          originalUrl: z10.string(),
-          reference: z10.string(),
-          commitSha: z10.string(),
-          isKnownBranch: z10.boolean().nullish().default(true)
+        repo: z7.object({
+          name: z7.string().nullable(),
+          originalUrl: z7.string(),
+          reference: z7.string(),
+          commitSha: z7.string(),
+          isKnownBranch: z7.boolean().nullish().default(true)
         }).nullable().transform(
           (repo) => repo ?? {
             name: null,
@@ -1936,229 +1937,229 @@ var init_types = __esm({
             isKnownBranch: true
           }
         ),
-        vulnerabilityReportIssuesFixedCount: z10.object({
-          vulnerabilityReportIssues_aggregate: z10.object({
-            aggregate: z10.object({ count: z10.number() })
+        vulnerabilityReportIssuesFixedCount: z7.object({
+          vulnerabilityReportIssues_aggregate: z7.object({
+            aggregate: z7.object({ count: z7.number() })
           })
         }),
-        vulnerabilityReport: z10.object({
-          id: z10.string().uuid(),
-          reportSummaryUrl: z10.string().url().nullish(),
-          computedVendor: z10.nativeEnum(Vulnerability_Report_Vendor_Enum).nullable(),
-          vendor: z10.nativeEnum(Vulnerability_Report_Vendor_Enum).nullable(),
-          issuesWithKnownLanguage: z10.number().nullable(),
-          scanDate: z10.string().nullable(),
-          vendorReportId: z10.string().uuid().nullable(),
-          projectId: z10.string().uuid(),
-          project: z10.object({
-            organizationId: z10.string().uuid()
+        vulnerabilityReport: z7.object({
+          id: z7.string().uuid(),
+          reportSummaryUrl: z7.string().url().nullish(),
+          computedVendor: z7.nativeEnum(Vulnerability_Report_Vendor_Enum).nullable(),
+          vendor: z7.nativeEnum(Vulnerability_Report_Vendor_Enum).nullable(),
+          issuesWithKnownLanguage: z7.number().nullable(),
+          scanDate: z7.string().nullable(),
+          vendorReportId: z7.string().uuid().nullable(),
+          projectId: z7.string().uuid(),
+          project: z7.object({
+            organizationId: z7.string().uuid()
           }),
-          file: z10.object({
-            id: z10.string().uuid(),
-            path: z10.string()
+          file: z7.object({
+            id: z7.string().uuid(),
+            path: z7.string()
           }).nullable(),
-          pending: z10.object({
-            aggregate: z10.object({
-              count: z10.number()
+          pending: z7.object({
+            aggregate: z7.object({
+              count: z7.number()
             })
           }),
-          irrelevant: z10.object({
-            aggregate: z10.object({
-              count: z10.number()
+          irrelevant: z7.object({
+            aggregate: z7.object({
+              count: z7.number()
             })
           }),
-          remaining: z10.object({
-            aggregate: z10.object({
-              count: z10.number()
+          remaining: z7.object({
+            aggregate: z7.object({
+              count: z7.number()
             })
           }),
-          digested: z10.object({
-            aggregate: z10.object({
-              count: z10.number()
+          digested: z7.object({
+            aggregate: z7.object({
+              count: z7.number()
             })
           }),
-          supported: z10.object({
-            aggregate: z10.object({
-              count: z10.number()
+          supported: z7.object({
+            aggregate: z7.object({
+              count: z7.number()
             })
           }),
-          all: z10.object({
-            aggregate: z10.object({
-              count: z10.number()
+          all: z7.object({
+            aggregate: z7.object({
+              count: z7.number()
             })
           }),
-          fixable: z10.object({
-            aggregate: z10.object({
-              count: z10.number()
+          fixable: z7.object({
+            aggregate: z7.object({
+              count: z7.number()
             })
           }),
-          errors: z10.object({
-            aggregate: z10.object({
-              count: z10.number()
+          errors: z7.object({
+            aggregate: z7.object({
+              count: z7.number()
             })
           }),
-          vulnerabilityReportIssues: z10.object({
-            id: z10.string().uuid(),
-            extraData: z10.object({
-              missing_files: z10.string().array().nullish(),
-              large_files: z10.string().array().nullish(),
-              error_files: z10.string().array().nullish(),
-              ai_cost_limit_exceeded: z10.string().nullish()
+          vulnerabilityReportIssues: z7.object({
+            id: z7.string().uuid(),
+            extraData: z7.object({
+              missing_files: z7.string().array().nullish(),
+              large_files: z7.string().array().nullish(),
+              error_files: z7.string().array().nullish(),
+              ai_cost_limit_exceeded: z7.string().nullish()
             })
           }).array()
         })
       })
     });
-    ReportFixesQueryFixZ = z10.object({
-      id: z10.string().uuid(),
+    ReportFixesQueryFixZ = z7.object({
+      id: z7.string().uuid(),
       sharedState: FixSharedStateZ,
-      confidence: z10.number(),
-      gitBlameLogin: z10.string().nullable(),
-      effortToApplyFix: z10.nativeEnum(Effort_To_Apply_Fix_Enum).nullable(),
-      safeIssueLanguage: z10.string(),
-      safeIssueType: z10.string(),
-      fixReportId: z10.string().uuid(),
-      filePaths: z10.array(
-        z10.object({
-          fileRepoRelativePath: z10.string()
+      confidence: z7.number(),
+      gitBlameLogin: z7.string().nullable(),
+      effortToApplyFix: z7.nativeEnum(Effort_To_Apply_Fix_Enum).nullable(),
+      safeIssueLanguage: z7.string(),
+      safeIssueType: z7.string(),
+      fixReportId: z7.string().uuid(),
+      filePaths: z7.array(
+        z7.object({
+          fileRepoRelativePath: z7.string()
         })
       ),
-      numberOfVulnerabilityIssues: z10.number(),
-      severityText: z10.nativeEnum(Vulnerability_Severity_Enum),
-      vulnerabilityReportIssues: z10.array(
-        z10.object({
-          issueType: z10.string(),
-          issueLanguage: z10.string(),
+      numberOfVulnerabilityIssues: z7.number(),
+      severityText: z7.nativeEnum(Vulnerability_Severity_Enum),
+      vulnerabilityReportIssues: z7.array(
+        z7.object({
+          issueType: z7.string(),
+          issueLanguage: z7.string(),
           sharedState: IssueSharedStateZ2
         })
       ).min(1)
     });
-    BaseVulnerabilityReportIssueZ = z10.object({
-      id: z10.string().uuid(),
-      createdAt: z10.string(),
-      state: z10.nativeEnum(Vulnerability_Report_Issue_State_Enum),
-      safeIssueType: z10.string(),
-      safeIssueLanguage: z10.string(),
-      extraData: z10.object({
-        missing_files: z10.string().array().nullish(),
-        large_files: z10.string().array().nullish(),
-        error_files: z10.string().array().nullish(),
-        ai_cost_limit_exceeded: z10.string().nullish()
+    BaseVulnerabilityReportIssueZ = z7.object({
+      id: z7.string().uuid(),
+      createdAt: z7.string(),
+      state: z7.nativeEnum(Vulnerability_Report_Issue_State_Enum),
+      safeIssueType: z7.string(),
+      safeIssueLanguage: z7.string(),
+      extraData: z7.object({
+        missing_files: z7.string().array().nullish(),
+        large_files: z7.string().array().nullish(),
+        error_files: z7.string().array().nullish(),
+        ai_cost_limit_exceeded: z7.string().nullish()
       }),
       fix: ReportFixesQueryFixZ.nullable(),
-      falsePositive: z10.object({
-        id: z10.string().uuid()
+      falsePositive: z7.object({
+        id: z7.string().uuid()
       }).nullable(),
       parsedSeverity: ParsedSeverityZ,
-      severity: z10.string(),
-      severityValue: z10.number(),
-      category: z10.string(),
-      vulnerabilityReportIssueTags: z10.array(
-        z10.object({
-          vulnerability_report_issue_tag_value: z10.string()
+      severity: z7.string(),
+      severityValue: z7.number(),
+      category: z7.string(),
+      vulnerabilityReportIssueTags: z7.array(
+        z7.object({
+          vulnerability_report_issue_tag_value: z7.string()
         })
       ),
       sharedState: VulnerabilityReportIssueSharedStateZ
     });
     VulnerabilityReportIssueZ = BaseVulnerabilityReportIssueZ.merge(
-      z10.object({
-        codeNodes: z10.array(z10.object({ path: z10.string() }))
+      z7.object({
+        codeNodes: z7.array(z7.object({ path: z7.string() }))
       })
     );
     VulnerabilityReportIssueWithCodeFilePathZ = BaseVulnerabilityReportIssueZ.merge(
-      z10.object({
-        codeFilePath: z10.string().nullable()
+      z7.object({
+        codeFilePath: z7.string().nullable()
       })
     );
-    GetReportIssuesQueryZ = z10.object({
-      fixReport: z10.object({
-        vulnerabilityReport: z10.object({
-          id: z10.string().uuid(),
-          lastIssueUpdatedAt: z10.string(),
-          vulnerabilityReportIssues_aggregate: z10.object({
-            aggregate: z10.object({ count: z10.number() })
+    GetReportIssuesQueryZ = z7.object({
+      fixReport: z7.object({
+        vulnerabilityReport: z7.object({
+          id: z7.string().uuid(),
+          lastIssueUpdatedAt: z7.string(),
+          vulnerabilityReportIssues_aggregate: z7.object({
+            aggregate: z7.object({ count: z7.number() })
           }),
-          vulnerabilityReportIssues: z10.array(
+          vulnerabilityReportIssues: z7.array(
             VulnerabilityReportIssueWithCodeFilePathZ
           )
         })
       }).array()
     }).nullish();
-    FixReportByProjectZ = z10.object({
-      project_by_pk: z10.object({
-        vulnerabilityReports: z10.array(
-          z10.object({
-            fixReport: z10.object({ id: z10.string().uuid() }).nullable()
+    FixReportByProjectZ = z7.object({
+      project_by_pk: z7.object({
+        vulnerabilityReports: z7.array(
+          z7.object({
+            fixReport: z7.object({ id: z7.string().uuid() }).nullable()
           })
         )
       })
     });
-    FixScreenQueryResultZ = z10.object({
+    FixScreenQueryResultZ = z7.object({
       fixReport_by_pk: FixPageFixReportZ,
       fix_by_pk: FixPartsForFixScreenZ,
-      fixesWithSameIssueType: z10.array(
-        z10.object({
-          id: z10.string().uuid(),
-          sharedState: z10.object({ state: z10.nativeEnum(Fix_State_Enum) }).nullable().default({ state: "Ready" /* Ready */ })
+      fixesWithSameIssueType: z7.array(
+        z7.object({
+          id: z7.string().uuid(),
+          sharedState: z7.object({ state: z7.nativeEnum(Fix_State_Enum) }).nullable().default({ state: "Ready" /* Ready */ })
         })
       ),
       relevantIssue: IssuePartsZ.nullish()
     });
-    FixPageQueryZ = z10.object({
+    FixPageQueryZ = z7.object({
       data: FixScreenQueryResultZ
     });
-    GetReportFixesQueryZ = z10.object({
-      fixReport: z10.array(
-        z10.object({
-          fixes: z10.array(ReportFixesQueryFixZ),
-          vulnerabilityReportIssuesTotalCount: z10.object({
-            vulnerabilityReportIssues_aggregate: z10.object({
-              aggregate: z10.object({ count: z10.number() })
+    GetReportFixesQueryZ = z7.object({
+      fixReport: z7.array(
+        z7.object({
+          fixes: z7.array(ReportFixesQueryFixZ),
+          vulnerabilityReportIssuesTotalCount: z7.object({
+            vulnerabilityReportIssues_aggregate: z7.object({
+              aggregate: z7.object({ count: z7.number() })
             })
           }),
-          vulnerabilityReportIssuesFixedCount: z10.object({
-            vulnerabilityReportIssues_aggregate: z10.object({
-              aggregate: z10.object({ count: z10.number() })
+          vulnerabilityReportIssuesFixedCount: z7.object({
+            vulnerabilityReportIssues_aggregate: z7.object({
+              aggregate: z7.object({ count: z7.number() })
             })
           }),
-          vulnerabilityReportIssuesIrrelevantCount: z10.object({
-            vulnerabilityReportIssues_aggregate: z10.object({
-              aggregate: z10.object({ count: z10.number() })
+          vulnerabilityReportIssuesIrrelevantCount: z7.object({
+            vulnerabilityReportIssues_aggregate: z7.object({
+              aggregate: z7.object({ count: z7.number() })
             })
           }),
-          vulnerabilityReportIssuesRemainingCount: z10.object({
-            vulnerabilityReportIssues_aggregate: z10.object({
-              aggregate: z10.object({ count: z10.number() })
+          vulnerabilityReportIssuesRemainingCount: z7.object({
+            vulnerabilityReportIssues_aggregate: z7.object({
+              aggregate: z7.object({ count: z7.number() })
             })
           })
         })
       )
     }).nullish();
-    GetFixReportStatsQueryZ = z10.object({
-      fixReport_by_pk: z10.object({
-        id: z10.string().uuid(),
-        vulnerabilitySeverities: z10.record(z10.nativeEnum(Vulnerability_Severity_Enum), z10.number()).nullable(),
-        vulnerabilityReportIrrelevantIssuesCount: z10.object({
-          vulnerabilityReportIssues_aggregate: z10.object({
-            aggregate: z10.object({ count: z10.number() })
+    GetFixReportStatsQueryZ = z7.object({
+      fixReport_by_pk: z7.object({
+        id: z7.string().uuid(),
+        vulnerabilitySeverities: z7.record(z7.nativeEnum(Vulnerability_Severity_Enum), z7.number()).nullable(),
+        vulnerabilityReportIrrelevantIssuesCount: z7.object({
+          vulnerabilityReportIssues_aggregate: z7.object({
+            aggregate: z7.object({ count: z7.number() })
           })
         })
       }).nullable()
     });
-    ProjectVulnerabilityReport = z10.object({
-      id: z10.string().uuid(),
-      name: z10.string().nullable(),
-      vendor: z10.nativeEnum(Vulnerability_Report_Vendor_Enum).nullable(),
-      computedVendor: z10.nativeEnum(Vulnerability_Report_Vendor_Enum).nullable(),
-      fixReport: z10.object({
-        id: z10.string().uuid(),
-        createdOn: z10.string(),
-        issueTypes: z10.record(z10.string(), z10.number()).nullable(),
-        issueLanguages: z10.record(z10.nativeEnum(IssueLanguage_Enum), z10.number()).nullable(),
-        repo: z10.object({
-          originalUrl: z10.string(),
-          reference: z10.string(),
-          name: z10.string()
+    ProjectVulnerabilityReport = z7.object({
+      id: z7.string().uuid(),
+      name: z7.string().nullable(),
+      vendor: z7.nativeEnum(Vulnerability_Report_Vendor_Enum).nullable(),
+      computedVendor: z7.nativeEnum(Vulnerability_Report_Vendor_Enum).nullable(),
+      fixReport: z7.object({
+        id: z7.string().uuid(),
+        createdOn: z7.string(),
+        issueTypes: z7.record(z7.string(), z7.number()).nullable(),
+        issueLanguages: z7.record(z7.nativeEnum(IssueLanguage_Enum), z7.number()).nullable(),
+        repo: z7.object({
+          originalUrl: z7.string(),
+          reference: z7.string(),
+          name: z7.string()
         }).nullable().transform(
           (repo) => repo ?? {
             originalUrl: "",
@@ -2166,64 +2167,64 @@ var init_types = __esm({
             name: ""
           }
         ),
-        createdByUser: z10.object({
-          email: z10.string()
+        createdByUser: z7.object({
+          email: z7.string()
         }).nullable(),
-        state: z10.nativeEnum(Fix_Report_State_Enum),
-        expirationOn: z10.string()
+        state: z7.nativeEnum(Fix_Report_State_Enum),
+        expirationOn: z7.string()
       })
     });
-    GetProjectsQueryZ = z10.object({
-      organization: z10.object({
-        id: z10.string(),
-        projects: z10.array(
-          z10.object({
-            id: z10.string().uuid(),
-            name: z10.string(),
-            numberOfUniqueRepos: z10.number()
+    GetProjectsQueryZ = z7.object({
+      organization: z7.object({
+        id: z7.string(),
+        projects: z7.array(
+          z7.object({
+            id: z7.string().uuid(),
+            name: z7.string(),
+            numberOfUniqueRepos: z7.number()
           })
         )
       })
     });
-    ProjectPageQueryResultZ = z10.object({
-      name: z10.string(),
-      id: z10.string().uuid(),
-      isDefault: z10.boolean().default(false),
-      organizationId: z10.string().uuid(),
-      vulnerabilityReports: z10.array(ProjectVulnerabilityReport),
-      autoPrIncludeAiFixes: z10.preprocess(
+    ProjectPageQueryResultZ = z7.object({
+      name: z7.string(),
+      id: z7.string().uuid(),
+      isDefault: z7.boolean().default(false),
+      organizationId: z7.string().uuid(),
+      vulnerabilityReports: z7.array(ProjectVulnerabilityReport),
+      autoPrIncludeAiFixes: z7.preprocess(
         (val) => val === null || val === void 0 ? false : val,
-        z10.boolean()
+        z7.boolean()
       ),
-      projectIssueTypeSettings: z10.array(
-        IssueTypeSettingZ.merge(z10.object({ id: z10.string() }))
+      projectIssueTypeSettings: z7.array(
+        IssueTypeSettingZ.merge(z7.object({ id: z7.string() }))
       )
     });
-    GetProjectMembersDataZ = z10.object({
-      project_by_pk: z10.object({
-        name: z10.string(),
-        id: z10.string(),
-        projectUsers: z10.array(
-          z10.object({
-            projectToRole: z10.object({
-              projectRole: z10.object({
-                type: z10.nativeEnum(Project_Role_Type_Enum)
+    GetProjectMembersDataZ = z7.object({
+      project_by_pk: z7.object({
+        name: z7.string(),
+        id: z7.string(),
+        projectUsers: z7.array(
+          z7.object({
+            projectToRole: z7.object({
+              projectRole: z7.object({
+                type: z7.nativeEnum(Project_Role_Type_Enum)
               })
             }),
-            user: z10.object({
-              id: z10.string().uuid(),
-              picture: z10.string().nullable().optional(),
-              name: z10.string().nullish(),
-              email: z10.string().email()
+            user: z7.object({
+              id: z7.string().uuid(),
+              picture: z7.string().nullable().optional(),
+              name: z7.string().nullish(),
+              email: z7.string().email()
             })
           })
         )
       })
     });
-    RepoArgsZ = z10.object({
-      originalUrl: z10.string().url(),
-      branch: z10.string(),
-      commitSha: z10.string()
+    RepoArgsZ = z7.object({
+      originalUrl: z7.string().url(),
+      branch: z7.string(),
+      commitSha: z7.string()
     });
     scmCloudUrl = {
       GitLab: "https://gitlab.com",
@@ -2257,7 +2258,7 @@ var init_types2 = __esm({
 });
 
 // src/features/analysis/scm/shared/src/urlParser/urlParser.ts
-import { z as z11 } from "zod";
+import { z as z8 } from "zod";
 function computeCanonicalUrl(data) {
   const {
     scmType,
@@ -2299,7 +2300,7 @@ function detectAdoUrl(args) {
         scmType: "Ado" /* Ado */,
         organization,
         // project has single repo - repoName === projectName
-        projectName: z11.string().parse(projectName),
+        projectName: z8.string().parse(projectName),
         repoName: projectName,
         prefixPath
       };
@@ -2310,7 +2311,7 @@ function detectAdoUrl(args) {
       return {
         scmType: "Ado" /* Ado */,
         organization,
-        projectName: z11.string().parse(projectName),
+        projectName: z8.string().parse(projectName),
         repoName,
         prefixPath
       };
@@ -2324,7 +2325,7 @@ function detectAdoUrl(args) {
           scmType: "Ado" /* Ado */,
           organization,
           // project has only one repo - repoName === projectName
-          projectName: z11.string().parse(repoName),
+          projectName: z8.string().parse(repoName),
           repoName,
           prefixPath
         };
@@ -2334,7 +2335,7 @@ function detectAdoUrl(args) {
         return {
           scmType: "Ado" /* Ado */,
           organization,
-          projectName: z11.string().parse(projectName),
+          projectName: z8.string().parse(projectName),
           repoName,
           prefixPath
         };
@@ -2410,7 +2411,7 @@ function parseSshUrl(scmURL, scmType) {
     if (pathElements.length === 3) {
       const [organization2, projectName, repoName2] = pathElements;
       if (organization2?.match(NAME_REGEX) && projectName && repoName2?.match(NAME_REGEX)) {
-        const parsedProjectName = z11.string().parse(projectName);
+        const parsedProjectName = z8.string().parse(projectName);
         return {
           scmType: "Ado" /* Ado */,
           hostname: normalizedHostname,
@@ -2638,17 +2639,17 @@ var init_urlParser2 = __esm({
 });
 
 // src/features/analysis/scm/env.ts
-import { z as z14 } from "zod";
+import { z as z11 } from "zod";
 var EnvVariablesZod, GITLAB_API_TOKEN, GITHUB_API_TOKEN, GIT_PROXY_HOST, MAX_UPLOAD_FILE_SIZE_MB, GITHUB_API_CONCURRENCY;
 var init_env = __esm({
   "src/features/analysis/scm/env.ts"() {
     "use strict";
-    EnvVariablesZod = z14.object({
-      GITLAB_API_TOKEN: z14.string().optional(),
-      GITHUB_API_TOKEN: z14.string().optional(),
-      GIT_PROXY_HOST: z14.string().optional().default("http://tinyproxy:8888"),
-      MAX_UPLOAD_FILE_SIZE_MB: z14.coerce.number().gt(0).default(2),
-      GITHUB_API_CONCURRENCY: z14.coerce.number().gt(0).optional().default(10)
+    EnvVariablesZod = z11.object({
+      GITLAB_API_TOKEN: z11.string().optional(),
+      GITHUB_API_TOKEN: z11.string().optional(),
+      GIT_PROXY_HOST: z11.string().optional().default("http://tinyproxy:8888"),
+      MAX_UPLOAD_FILE_SIZE_MB: z11.coerce.number().gt(0).default(2),
+      GITHUB_API_CONCURRENCY: z11.coerce.number().gt(0).optional().default(10)
     });
     ({
       GITLAB_API_TOKEN,
@@ -2685,7 +2686,7 @@ var init_configs = __esm({
 });
 
 // src/utils/blame/gitBlameTypes.ts
-import { z as z17 } from "zod";
+import { z as z14 } from "zod";
 function parseCoAuthorValue(raw) {
   const trimmed = raw.trim();
   if (!trimmed) {
@@ -2721,9 +2722,9 @@ var PrepareGitBlameMessageZ, PrepareGitBlameResponseMessageZ, CommitMetadataZ, L
 var init_gitBlameTypes = __esm({
   "src/utils/blame/gitBlameTypes.ts"() {
     "use strict";
-    PrepareGitBlameMessageZ = z17.object({
-      reportId: z17.string(),
-      repoArchivePath: z17.string(),
+    PrepareGitBlameMessageZ = z14.object({
+      reportId: z14.string(),
+      repoArchivePath: z14.string(),
       // Optional list of file paths to blame. Producers must pick one of two modes:
       //
       //  - **Omit `filePaths`** = "blame every file in the archive". Used by the
@@ -2739,132 +2740,132 @@ var init_gitBlameTypes = __esm({
       // "Login.java" when the actual file is "src/main/java/Login.java") are
       // tolerated — scm_agent's filter matches exact-or-trailing-basename. Empty
       // strings are filtered out defensively.
-      filePaths: z17.array(z17.string()).optional()
-    });
-    PrepareGitBlameResponseMessageZ = z17.object({
-      reportId: z17.string()
-    });
-    CommitMetadataZ = z17.object({
-      author: z17.string().optional(),
-      "author-mail": z17.string().optional(),
-      "author-time": z17.string().optional(),
-      "author-tz": z17.string().optional(),
-      committer: z17.string().optional(),
-      "committer-mail": z17.string().optional(),
-      "committer-time": z17.string().optional(),
-      "committer-tz": z17.string().optional(),
-      summary: z17.string().optional(),
-      filename: z17.string().optional()
-    });
-    LineToCommitMapZ = z17.record(z17.string(), z17.string());
-    CommitMetadataMapZ = z17.record(z17.string(), CommitMetadataZ);
-    BlameInfoZ = z17.object({
+      filePaths: z14.array(z14.string()).optional()
+    });
+    PrepareGitBlameResponseMessageZ = z14.object({
+      reportId: z14.string()
+    });
+    CommitMetadataZ = z14.object({
+      author: z14.string().optional(),
+      "author-mail": z14.string().optional(),
+      "author-time": z14.string().optional(),
+      "author-tz": z14.string().optional(),
+      committer: z14.string().optional(),
+      "committer-mail": z14.string().optional(),
+      "committer-time": z14.string().optional(),
+      "committer-tz": z14.string().optional(),
+      summary: z14.string().optional(),
+      filename: z14.string().optional()
+    });
+    LineToCommitMapZ = z14.record(z14.string(), z14.string());
+    CommitMetadataMapZ = z14.record(z14.string(), CommitMetadataZ);
+    BlameInfoZ = z14.object({
       lineToCommit: LineToCommitMapZ,
       commitMetadata: CommitMetadataMapZ
     });
-    LineRangeZ = z17.object({
+    LineRangeZ = z14.object({
       /** First line in chunk (1-indexed) */
-      start: z17.number(),
+      start: z14.number(),
       /** Last line in chunk (inclusive) */
-      end: z17.number()
-    });
-    PrContextZ = z17.object({
-      prNumber: z17.number(),
-      repositoryUrl: z17.string(),
-      organizationId: z17.string(),
-      userEmail: z17.string(),
-      source: z17.enum(["pr", "github"]),
-      githubContext: z17.object({
-        prNumber: z17.number(),
-        installationId: z17.number(),
-        repositoryURL: z17.string()
+      end: z14.number()
+    });
+    PrContextZ = z14.object({
+      prNumber: z14.number(),
+      repositoryUrl: z14.string(),
+      organizationId: z14.string(),
+      userEmail: z14.string(),
+      source: z14.enum(["pr", "github"]),
+      githubContext: z14.object({
+        prNumber: z14.number(),
+        installationId: z14.number(),
+        repositoryURL: z14.string()
       }).optional()
     });
-    PrepareCommitBlameMessageZ = z17.object({
+    PrepareCommitBlameMessageZ = z14.object({
       /** Commit blame request ID from database (for tracking and updating status) */
-      commitBlameRequestId: z17.string(),
+      commitBlameRequestId: z14.string(),
       /** Organization ID (for org-scoped caching) */
-      organizationId: z17.string(),
+      organizationId: z14.string(),
       /** Full repository URL (e.g., https://github.com/org/repo) */
-      repositoryUrl: z17.string(),
+      repositoryUrl: z14.string(),
       /** Commit SHA to analyze (typically PR head commit) */
-      commitSha: z17.string(),
+      commitSha: z14.string(),
       /** Authentication headers for repository access (e.g., GitHub token) */
-      extraHeaders: z17.record(z17.string(), z17.string()).default({}),
+      extraHeaders: z14.record(z14.string(), z14.string()).default({}),
       // --- PR analysis fields ---
       /** Target branch name (from getPr() base.ref). When set, enables PR analysis mode. */
-      targetBranch: z17.string().optional(),
+      targetBranch: z14.string().optional(),
       /** Context for triggering blame attribution analysis after SCM agent completes. */
       prContext: PrContextZ.optional(),
       /** User email for blame attribution analysis trigger context (used for both PR and single commit flows). */
-      userEmail: z17.string().optional()
+      userEmail: z14.string().optional()
     });
-    BlameLineInfoZ = z17.object({
+    BlameLineInfoZ = z14.object({
       /** Line number as it appeared in the introducing commit */
-      originalLineNumber: z17.number(),
+      originalLineNumber: z14.number(),
       /** Commit SHA that introduced this line */
-      commitSha: z17.string(),
+      commitSha: z14.string(),
       /** Author name for this line */
-      authorName: z17.string().optional(),
+      authorName: z14.string().optional(),
       /** Author email for this line */
-      authorEmail: z17.string().optional()
+      authorEmail: z14.string().optional()
     }).nullable();
-    FileBlameDataZ = z17.array(BlameLineInfoZ);
-    ChunkFetchResultZ = z17.object({
-      filePath: z17.string(),
-      lines: z17.array(z17.number()),
+    FileBlameDataZ = z14.array(BlameLineInfoZ);
+    ChunkFetchResultZ = z14.object({
+      filePath: z14.string(),
+      lines: z14.array(z14.number()),
       data: FileBlameDataZ.nullable()
     });
-    FileBlameResponseEntryZ = z17.object({
+    FileBlameResponseEntryZ = z14.object({
       /** Chunk index (0 for small files, 0-N for large file chunks) */
-      chunkIndex: z17.number(),
+      chunkIndex: z14.number(),
       /** Blame data array (1-indexed, index 0 is null) */
       blameData: FileBlameDataZ
     });
-    CommitBlameDataZ = z17.record(
-      z17.string(),
+    CommitBlameDataZ = z14.record(
+      z14.string(),
       // fileName
-      z17.array(FileBlameResponseEntryZ)
+      z14.array(FileBlameResponseEntryZ)
     );
-    CommitInfoZ = z17.object({
+    CommitInfoZ = z14.object({
       /** Number of parent commits (1 = normal commit, 2+ = merge commit, null = failed to determine) */
-      parentCount: z17.number().nullable()
+      parentCount: z14.number().nullable()
     });
-    GitIdentityZ = z17.object({
-      name: z17.string(),
-      email: z17.string()
+    GitIdentityZ = z14.object({
+      name: z14.string(),
+      email: z14.string()
     });
     COMMIT_LOG_FORMAT = "%H%x00%ae%x00%an%x00%ce%x00%cn%x00%at%x00%s%x00%(trailers:key=Co-authored-by,valueonly,separator=%x00)";
-    CommitDataZ = z17.object({
-      diff: z17.string(),
+    CommitDataZ = z14.object({
+      diff: z14.string(),
       author: GitIdentityZ,
       committer: GitIdentityZ,
-      coAuthors: z17.array(GitIdentityZ),
-      timestamp: z17.number(),
+      coAuthors: z14.array(GitIdentityZ),
+      timestamp: z14.number(),
       // Unix timestamp in seconds
-      message: z17.string().optional(),
-      parentCount: z17.number().nullable()
+      message: z14.string().optional(),
+      parentCount: z14.number().nullable()
     });
-    PrDiffDataZ = z17.object({
-      diff: z17.string()
+    PrDiffDataZ = z14.object({
+      diff: z14.string()
     });
-    PrStatsZ = z17.object({
-      additions: z17.number(),
-      deletions: z17.number()
+    PrStatsZ = z14.object({
+      additions: z14.number(),
+      deletions: z14.number()
     });
-    CommitsManifestZ = z17.object({
-      commits: z17.array(z17.string())
+    CommitsManifestZ = z14.object({
+      commits: z14.array(z14.string())
       // Array of commit SHAs in order
     });
-    BlameLineEntryZ = z17.object({
+    BlameLineEntryZ = z14.object({
       /** Current file path in the PR head (what git blame was invoked on). */
-      file: z17.string(),
+      file: z14.string(),
       /** Current line number in the PR head. */
-      line: z17.number(),
+      line: z14.number(),
       /** SHA of the commit that originally authored this line. */
-      originalCommitSha: z17.string(),
+      originalCommitSha: z14.string(),
       /** Line number as it was in `originalCommitSha`. */
-      originalLineNumber: z17.number(),
+      originalLineNumber: z14.number(),
       /**
        * File path as it was in `originalCommitSha` at the time that commit
        * authored this line. When a file has been renamed since, this differs
@@ -2877,24 +2878,24 @@ var init_gitBlameTypes = __esm({
        * must treat empty as "fall back to `file`" (see enrichDiffLines,
        * targetedBlame).
        */
-      originalFile: z17.string().default("")
+      originalFile: z14.string().default("")
     });
-    BlameLinesDataZ = z17.object({
-      lines: z17.array(BlameLineEntryZ)
+    BlameLinesDataZ = z14.object({
+      lines: z14.array(BlameLineEntryZ)
     });
-    PrepareCommitBlameResponseMessageZ = z17.object({
+    PrepareCommitBlameResponseMessageZ = z14.object({
       /** Commit blame request ID (matches request, used to update specific DB record) */
-      commitBlameRequestId: z17.string(),
+      commitBlameRequestId: z14.string(),
       /** Organization ID (matches request) */
-      organizationId: z17.string(),
+      organizationId: z14.string(),
       /** Repository URL (matches request) */
-      repositoryUrl: z17.string(),
+      repositoryUrl: z14.string(),
       /** Commit SHA analyzed (matches request) */
-      commitSha: z17.string(),
+      commitSha: z14.string(),
       /** Processing status */
-      status: z17.enum(["success", "failure"]),
+      status: z14.enum(["success", "failure"]),
       /** Error message (only present if status is 'failure') */
-      error: z17.string().optional(),
+      error: z14.string().optional(),
       /**
        * Blame data for all processed files/chunks.
        * Empty dictionary if status is 'failure'.
@@ -2906,29 +2907,29 @@ var init_gitBlameTypes = __esm({
        * Keyed by commit SHA, deduplicated.
        * Empty dictionary if status is 'failure'.
        */
-      commits: z17.record(z17.string(), CommitInfoZ).default({}),
+      commits: z14.record(z14.string(), CommitInfoZ).default({}),
       // --- New PR diff computation response fields ---
       /** S3 paths for commit-level data (commitSha → S3 key). Present in PR analysis mode and single commit mode. */
-      commitDataS3Paths: z17.record(z17.string(), z17.string()).optional(),
+      commitDataS3Paths: z14.record(z14.string(), z14.string()).optional(),
       /** S3 key for PR diff JSON. Present in PR analysis mode. */
-      prDiffS3Path: z17.string().optional(),
+      prDiffS3Path: z14.string().optional(),
       /** S3 key for commits manifest. Present in PR analysis mode. */
-      commitsManifestS3Path: z17.string().optional(),
+      commitsManifestS3Path: z14.string().optional(),
       /** S3 key for per-line targeted blame data. Present in PR analysis mode. */
-      blameLinesS3Path: z17.string().optional(),
+      blameLinesS3Path: z14.string().optional(),
       /** S3 key for PR stats (additions/deletions). Present in PR analysis mode. */
-      prStatsS3Path: z17.string().optional(),
+      prStatsS3Path: z14.string().optional(),
       /** PR context passed through from request for response handler. */
       prContext: PrContextZ.optional(),
       /** PR title from the request metadata (passed through). */
-      prTitle: z17.string().optional(),
+      prTitle: z14.string().optional(),
       /** User email passed through from request for single commit blame attribution analysis trigger. */
-      userEmail: z17.string().optional()
+      userEmail: z14.string().optional()
     });
-    VulnerabilityAttributionMessageZ = z17.object({
-      fixReportId: z17.string().uuid(),
-      vulnerabilityAttributionRequestId: z17.string().uuid(),
-      userEmail: z17.string()
+    VulnerabilityAttributionMessageZ = z14.object({
+      fixReportId: z14.string().uuid(),
+      vulnerabilityAttributionRequestId: z14.string().uuid(),
+      userEmail: z14.string()
     });
   }
 });
@@ -4262,1755 +4263,176 @@ var contextLogger = {
     const logger3 = await createContextLogger();
     return logger3.warn(message, data);
   },
-  error: async (message, data) => {
-    const logger3 = await createContextLogger();
-    return logger3.error(message, data);
-  }
-};
-
-// src/features/analysis/scm/errors.ts
-var InvalidAccessTokenError = class extends Error {
-  constructor(m, scmType) {
-    super(m);
-    this.scmType = scmType;
-  }
-};
-var InvalidUrlPatternError = class extends Error {
-  constructor(m, scmType) {
-    super(m);
-    this.scmType = scmType;
-  }
-};
-var RefNotFoundError = class extends Error {
-  constructor(m) {
-    super(m);
-  }
-};
-var ScmBadCredentialsError = class extends Error {
-  constructor(m, scmType) {
-    super(m);
-    this.scmType = scmType;
-  }
-};
-var InvalidRepoUrlError = class extends Error {
-  constructor(m, scmType) {
-    super(m);
-    this.scmType = scmType;
-  }
-};
-var RepoNoTokenAccessError = class extends Error {
-  constructor(m, scmType) {
-    super(m);
-    this.scmType = scmType;
-  }
-};
-var RateLimitError = class extends Error {
-  constructor(m, scmType, retryAfter) {
-    super(m);
-    this.scmType = scmType;
-    this.retryAfter = retryAfter;
-  }
-};
-var NetworkError = class extends Error {
-  constructor(m, scmType, errorCode) {
-    super(m);
-    this.scmType = scmType;
-    this.errorCode = errorCode;
-  }
-};
-
-// src/features/analysis/scm/utils/index.ts
-import { z as z13 } from "zod";
-
-// src/features/analysis/scm/shared/src/commitDescriptionMarkup.ts
-init_client_generates();
-init_getIssueType();
-init_issueTypeCatalog();
-function capitalizeFirstLetter(str) {
-  return str?.length ? str[0].toUpperCase() + str.slice(1) : "";
-}
-function lowercaseFirstLetter(str) {
-  if (!str) return str;
-  return `${str.charAt(0).toLowerCase()}${str.slice(1)}`;
-}
-var severityToEmoji = {
-  ["critical" /* Critical */]: "\u{1F6A8}",
-  ["high" /* High */]: "\u{1F6A9}",
-  ["medium" /* Medium */]: "\u{1F7E1}",
-  ["low" /* Low */]: "\u{1F7E2}"
-};
-var getCommitDescription = ({
-  vendor,
-  issueType,
-  severity,
-  guidances,
-  fixUrl,
-  irrelevantIssueWithTags
-}) => {
-  const issueTypeString = getIssueTypeFriendlyString(issueType);
-  let description = `This change fixes a **${severity} severity** (${severityToEmoji[severity]}) **${issueTypeString}** issue reported by **${capitalizeFirstLetter(
-    vendor
-  )}**.
-
-`;
-  if (issueType) {
-    if (irrelevantIssueWithTags?.[0]?.tag) {
-      description += `
-> [!tip]
-> This issue was found to be irrelevant to your project - ${lowercaseFirstLetter(getTagTooltip(irrelevantIssueWithTags[0].tag))}.
-> Mobb recommends to ignore this issue, however fix is available if you think differently. 
-
-
-## Justification
-${issueDescription[irrelevantIssueWithTags[0].tag]}
-`;
-    }
-    const catalogEntry = getIssueTypeCatalogEntry(issueType);
-    if (catalogEntry?.issueDescription) {
-      description += `## Issue description
-${catalogEntry.issueDescription}
-`;
-      if (catalogEntry.fixInstructions) {
-        description += `
-## Fix instructions
-${catalogEntry.fixInstructions}
-`;
-      }
-    }
-  }
-  description += `
-${guidances.map(({ guidance }) => `## Additional actions required
- ${guidance}
-`).join("")}
-`;
-  if (fixUrl) {
-    description += `
-[More info and fix customization are available in the Mobb platform](${fixUrl})`;
-  }
-  return description;
-};
-var getCommitIssueDescription = ({
-  vendor,
-  issueType,
-  irrelevantIssueWithTags,
-  fpDescription,
-  unfixableDescription
-}) => {
-  const issueTypeString = getIssueTypeFriendlyString(issueType);
-  let description = `The following issues reported by ${capitalizeFirstLetter(vendor)} on this PR were found to be irrelevant to your project:
-`;
-  if (issueType) {
-    if (irrelevantIssueWithTags?.[0]?.tag) {
-      description = `
-> [!tip]
-> The following issues reported by ${capitalizeFirstLetter(vendor)} on this PR were found to be irrelevant to your project:
-> ${issueTypeString} - ${lowercaseFirstLetter(getTagTooltip(irrelevantIssueWithTags[0].tag))}.
-> Mobb recommends to ignore this issue, however fix is available if you think differently. 
-
-
-## Justification
-${fpDescription ?? unfixableDescription ?? issueDescription[irrelevantIssueWithTags[0].tag]}
-`;
-    }
-    const catalogEntry = getIssueTypeCatalogEntry(issueType);
-    if (catalogEntry?.issueDescription) {
-      description += `## Issue description
-${catalogEntry.issueDescription}
-`;
-    }
-  }
-  return description;
-};
-
-// src/features/analysis/scm/shared/src/index.ts
-init_getIssueType();
-
-// src/features/analysis/scm/shared/src/guidances.ts
-init_client_generates();
-init_getIssueType();
-import { z as z4 } from "zod";
-
-// src/features/analysis/scm/shared/src/storedFixData/index.ts
-init_client_generates();
-import { z as z2 } from "zod";
-
-// src/features/analysis/scm/shared/src/storedFixData/passwordInComment.ts
-var passwordInComment = {
-  guidance: () => "Removing sensitive information from the comments is not enough. To ensure the security of your data, you have to rotate passwords and tokens and update all places where they were used."
-};
-
-// src/features/analysis/scm/shared/src/storedFixData/csharp/missingAntiForgeryValidation.ts
-var missingAntiForgeryValidation = {
-  guidance: () => `The \`ValidateAntiForgeryToken\` attribute helps prevent cross-site request forgery (CSRF) attacks.    The token is automatically injected into the view by the [FormTagHelper](https://learn.microsoft.com/en-us/aspnet/core/mvc/views/working-with-forms?view=aspnetcore-8.0#the-form-tag-helper)
-    and is included when the form is submitted by the user.    The token is validated by the \`ValidateAntiForgeryToken\` attribute.    The token could be also generated using the [Html.AntiForgeryToken](https://learn.microsoft.com/en-us/dotnet/api/system.web.mvc.htmlhelper.antiforgerytoken?view=aspnet-mvc-5.2) helper.    
-    
- 
-    
-    
-***Make sure this controller's client provides the validation token before approving this change.***  
-    
- 
-    
-    
-This is an illustration of how the form will look like:
-    
- 
-
-    <form method="post" action="/Action">
-        <!-- Input and Submit elements -->
-        <input name="__RequestVerificationToken" 
-        type="hidden" value="<removed for brevity>">
-    </form>
-    
-    
-***Notice the \`__RequestVerificationToken\` parameters.***
-    `
-};
-
-// src/features/analysis/scm/shared/src/storedFixData/csharp/index.ts
-var vulnerabilities = {
-  ["MISSING_ANTIFORGERY_VALIDATION"]: missingAntiForgeryValidation,
-  ["PASSWORD_IN_COMMENT"]: passwordInComment
-};
-var csharp_default = vulnerabilities;
-
-// src/features/analysis/scm/shared/src/storedFixData/dockerfile/index.ts
-var vulnerabilities2 = {};
-var dockerfile_default = vulnerabilities2;
-
-// src/features/analysis/scm/shared/src/storedFixData/go/index.ts
-var vulnerabilities3 = {};
-var go_default = vulnerabilities3;
-
-// src/features/analysis/scm/shared/src/storedFixData/hcl/index.ts
-var vulnerabilities4 = {};
-var hcl_default = vulnerabilities4;
-
-// src/features/analysis/scm/shared/src/storedFixData/java/insecureDeserialization.ts
-var insecureDeserialization = {
-  guidance: () => "Added a `@Consumes` annotation restricting the endpoint to common safe media types (JSON, XML, form, multipart, octet-stream, plain text). Requests with `Content-Type: application/x-java-serialized-object` are no longer routed to the RESTEasy `SerializableProvider`. If your endpoint legitimately accepts a content type not in this allowlist (e.g. `image/png`, a custom JSON variant), expect HTTP 415 from those clients and extend the `@Consumes` list to include it."
-};
-
-// src/features/analysis/scm/shared/src/storedFixData/java/j2eeGetConnection.ts
-var j2eeGetConnection = {
-  guidance: () => `This fix replaces direct \`DriverManager.getConnection(...)\` calls with a container-managed JNDI \`DataSource\` lookup. The new code expects the app server (Tomcat / WildFly / WebSphere / etc.) to expose a configured connection pool under the JNDI name you specified.
-
-
-&nbsp;
-
-***Make sure the resource pool exists before merging.*** The patched code will throw a \`NamingException\` at runtime if the JNDI name does not resolve. Configure it in your container's resource definition:
-
-- **Tomcat**: declare a \`<Resource>\` element in \`context.xml\` (or per-app \`META-INF/context.xml\`) with the same JNDI name, plus \`url\`, \`username\`, \`password\`, \`driverClassName\`, and any pool sizing.
-- **Spring Boot (embedded Tomcat)**: configure via \`spring.datasource.jndi-name\` and matching \`<Resource>\`, or use \`@ConfigurationProperties\` to bind a \`DataSource\` bean.
-- **WildFly / JBoss EAP**: declare a \`<datasource>\` in the standalone/domain XML and reference its JNDI binding.
-- **WebSphere / WebLogic**: define the JDBC provider and data source through the admin console; bind it to the JNDI name.
-
-
-&nbsp;
-
-Also add a matching \`<resource-ref>\` (or \`<data-source>\`) in your \`WEB-INF/web.xml\` if you use one. The original connection details (URL, user, password) move from the call site into the resource definition \u2014 remove them from any constants / properties files where they were duplicated.
-
-
-&nbsp;
-
-This fix is mandated by the J2EE / Jakarta EE specification (CWE-245) \u2014 direct driver management bypasses the container's pooling, retry, and failover policies.`
-};
-
-// src/features/analysis/scm/shared/src/storedFixData/java/systemInformationLeak.ts
-var systemInformationLeak = {
-  guidance: ({
-    clientMightBeAffected
-  }) => {
-    if (clientMightBeAffected) {
-      return "You should never expose error details to the client. We removed the error details from the response. Ensure the client application code does not rely on the removed information.";
-    }
-    return "";
-  }
-};
-
-// src/features/analysis/scm/shared/src/storedFixData/java/index.ts
-var vulnerabilities5 = {
-  ["PASSWORD_IN_COMMENT"]: passwordInComment,
-  ["INSECURE_DESERIALIZATION"]: insecureDeserialization,
-  ["J2EE_GET_CONNECTION"]: j2eeGetConnection,
-  ["SYSTEM_INFORMATION_LEAK"]: systemInformationLeak
-};
-var java_default = vulnerabilities5;
-
-// src/features/analysis/scm/shared/src/storedFixData/python/csrf.ts
-var csrf = {
-  guidance: () => `Please make sure the CSRF middleware is activated by default in the MIDDLEWARE setting. If you override that setting, remember that \`django.middleware.csrf.CsrfViewMiddleware\` should come before any view middleware that assume that CSRF attacks have been dealt with.
-
-
-If you disabled it, which is not recommended, you can use [\`csrf_protect()\`](https://docs.djangoproject.com/en/5.1/ref/csrf/#django.views.decorators.csrf.csrf_protect) annotation on this particular view.
-
-
-See more information [here](https://docs.djangoproject.com/en/5.1/howto/csrf/).`
-};
-
-// src/features/analysis/scm/shared/src/storedFixData/javascript/hardcodedSecrets.ts
-var hardcodedSecrets = {
-  guidance: ({ questions }) => {
-    const envVarName = questions.find((q) => q.key === "env_var_name")?.value || "the";
-    const keepAsDefault = questions.find(
-      (q) => q.key === "keep_as_default"
-    )?.value;
-    let additionalText = "";
-    if (keepAsDefault === "yes") {
-      additionalText = "\n1. Remove the hardcoded secret from the code.\n";
-    }
-    return `Please follow the steps in this specific order:
-
-1. Change the secret that was hardcoded. It is essential because even when you commit the changes, the secret will remain in the git history.${additionalText}
-1. Update the configuration of all your application environments and CI/CD pipelines to set \`${envVarName}\` environment variable.
-1. Commit the changes.`;
-  }
-};
-
-// src/features/analysis/scm/shared/src/storedFixData/javascript/noLimitsOrThrottling.ts
-var noLimitsOrThrottling = {
-  guidance: () => "We set the default limit to 60 requests per minute. To customize the rate limit settings, please read the documentation of the [express-rate-limit](https://www.npmjs.com/package/express-rate-limit) package."
-};
-
-// src/features/analysis/scm/shared/src/storedFixData/javascript/ssrf.ts
-var ssrf = {
-  guidance: () => "The server-side validates the domains it has access to, otherwise it throws an error if validation failed. Please make sure you handled the error correctly."
-};
-
-// src/features/analysis/scm/shared/src/storedFixData/javascript/index.ts
-var vulnerabilities6 = {
-  ["SSRF"]: ssrf,
-  ["HARDCODED_SECRETS"]: hardcodedSecrets,
-  ["PASSWORD_IN_COMMENT"]: passwordInComment,
-  ["NO_LIMITS_OR_THROTTLING"]: noLimitsOrThrottling,
-  ["CSRF"]: csrf
-};
-var javascript_default = vulnerabilities6;
-
-// src/features/analysis/scm/shared/src/storedFixData/php/index.ts
-var vulnerabilities7 = {};
-var php_default = vulnerabilities7;
-
-// src/features/analysis/scm/shared/src/storedFixData/python/autoEscapeFalse.ts
-var autoEscapeFalse = {
-  guidance: () => `This fix enables automatic escaping for HTML. When that's enabled, everything is escaped by default except for values explicitly marked as safe. Variables and expressions can be marked as safe either in:
-
-a. The context dictionary by the application with \`markupsafe.Markup\`
-
-b. The template, with the \`|safe\` filter.
-
-&nbsp;
-
-
-See more information [here](https://jinja.palletsprojects.com/en/3.1.x/templates/#working-with-automatic-escaping) and [here](https://pypi.org/project/MarkupSafe/).
-
-&nbsp;
-
-
-***Note: make sure that none of the data you're marking as safe is coming from user input, as this can lead to XSS vulnerabilities!***`
-};
-
-// src/features/analysis/scm/shared/src/storedFixData/python/improperCertificateValidation.ts
-var improperCertificateValidation = {
-  guidance: () => `This fix re-enables TLS certificate validation by changing \`verify=False\` to \`verify=True\` on the HTTP request. Any call that was deliberately reaching a server with a self-signed, expired, or otherwise untrusted certificate will start raising \`ssl.SSLError\` / \`requests.exceptions.SSLError\` after this change.
-
-&nbsp;
-
-***Before merging, confirm that every endpoint reached by this call presents a certificate signed by a trusted CA.*** If the call must talk to an internal service that uses a private CA, prefer pointing \`verify\` at the CA bundle (\`verify="/path/to/ca.pem"\`) over disabling validation. If the certificate cannot be trusted at all, the safe fix is to terminate that connection at a properly configured proxy, not to keep it unvalidated.
-
-&nbsp;
-
-See the [\`requests\` SSL verification docs](https://requests.readthedocs.io/en/latest/user/advanced/#ssl-cert-verification) for the supported \`verify\` values.`
-};
-
-// src/features/analysis/scm/shared/src/storedFixData/python/index.ts
-var vulnerabilities8 = {
-  ["AUTO_ESCAPE_FALSE"]: autoEscapeFalse,
-  ["CSRF"]: csrf,
-  ["IMPROPER_CERTIFICATE_VALIDATION"]: improperCertificateValidation
-};
-var python_default = vulnerabilities8;
-
-// src/features/analysis/scm/shared/src/storedFixData/sql/defaultRightsInObjDefinition.ts
-var defaultRightsInObjDefinition = {
-  guidance: () => "***Make sure the user who is supposed to run the procedure has sufficient permissions.***\n\nRead more details about the `EXECUTE AS` statement in [the official Microsoft documentation](https://learn.microsoft.com/en-us/sql/t-sql/statements/execute-as-clause-transact-sql?view=sql-server-ver16&tabs=sqlserver).\n\n`EXECUTE AS CALLER` is the default behavior for SQL Server 2005 and later."
-};
-
-// src/features/analysis/scm/shared/src/storedFixData/sql/index.ts
-var vulnerabilities9 = {
-  ["DEFAULT_RIGHTS_IN_OBJ_DEFINITION"]: defaultRightsInObjDefinition
-};
-var sql_default = vulnerabilities9;
-
-// src/features/analysis/scm/shared/src/storedFixData/xml/index.ts
-var vulnerabilities10 = {
-  ["PASSWORD_IN_COMMENT"]: passwordInComment
-};
-var xml_default = vulnerabilities10;
-
-// src/features/analysis/scm/shared/src/storedFixData/index.ts
-var StoredFixDataItemZ = z2.object({
-  guidance: z2.function().args(z2.any()).returns(z2.string())
-});
-var languages = {
-  ["Java" /* Java */]: java_default,
-  ["JavaScript" /* JavaScript */]: javascript_default,
-  ["CSharp" /* CSharp */]: csharp_default,
-  ["SQL" /* Sql */]: sql_default,
-  ["XML" /* Xml */]: xml_default,
-  ["Python" /* Python */]: python_default,
-  ["PHP" /* Php */]: php_default,
-  ["Go" /* Go */]: go_default,
-  ["Dockerfile" /* Dockerfile */]: dockerfile_default,
-  ["Hcl" /* Hcl */]: hcl_default
-};
-
-// src/features/analysis/scm/shared/src/storedQuestionData/index.ts
-init_client_generates();
-import { z as z3 } from "zod";
-
-// src/features/analysis/scm/shared/src/storedQuestionData/cpp/commandInjection.ts
-var commandInjection = {
-  isUnixShellCommandPart: {
-    content: () => "Is the input data interpolated into a shell command (not the program name or shell structure)?",
-    description: () => `\`system()\` / \`popen()\` hand the whole string to \`/bin/sh -c\`. Answer **yes** when the input is *data* placed into a fixed command, for example:
-
-- \`sprintf(cmd, "grep %s file.txt", input); system(cmd);\`
-- \`sprintf(cmd, "ping -c 5 %s", input); system(cmd);\`
-
-Answer **no** (the input is not plain data) when the input is:
-
-1. The program/executable itself:
-  - \`system(input);\`
-  - \`sprintf(cmd, "%s -x", input);\`
-2. A command after a pipe or redirect:
-  - \`sprintf(cmd, "cat file.txt | %s", input);\`
-3. A part of a non-Unix or cross-platform shell command.
-4. A part of embedded code in another language:
-  - \`sprintf(cmd, "php -r \\"echo '%s';\\"", input);\`
-  - \`sprintf(cmd, "awk '%s' file", input);\`
-5. A flag/option that controls a tool's behaviour:
-  - \`sprintf(cmd, "git --upload-pack %s", input);\``,
-    guidance: () => "If yes and the command can run without a shell, it is rewritten to a no-shell argument-vector call (`posix_spawn`); if it needs the shell, the tainted argument is escaped in place so the shell keeps working. If the answer is no (the input controls the program or shell structure), there is no safe automatic rewrite, so the fix is withheld and the sink is left for manual review."
-  },
-  executableLocationPath: {
-    content: () => "What is the absolute path of the directory containing the executable?",
-    description: () => `When \`system()\` is rewritten to an \`execv()\` argument-vector call, the program is run by its path with **no \`$PATH\` search**, so a relative program name (e.g. \`tail\`) cannot be resolved and a poisoned \`PATH\` cannot be used to run a look-alike binary.
-
-Provide the absolute directory that contains the executable (e.g. \`/usr/bin\`); the fix prepends it to the bare program name to form an absolute path.`,
-    guidance: () => "Only asked when the program name in the command has no `/`. A program that is already an absolute or relative path (contains `/`) is used as written."
-  }
-};
-
-// src/features/analysis/scm/shared/src/storedQuestionData/cpp/pathManipulation.ts
-var pathManipulation = {
-  baseDirectory: {
-    content: ({ expression }) => `Which directory must \`${expression}\` stay within? Enter the absolute base directory file access is restricted to.`,
-    description: ({ expression }) => `The fix canonicalizes \`${expression}\` (resolving \`.\`, \`..\`, and symlinks) and verifies the result stays inside this base directory. Provide the **absolute** root the application is allowed to read or write under, for example \`/var/app/data\`. The directory must exist at runtime. A path that resolves outside it is rejected at runtime.`,
-    guidance: (_) => "You **must** set this to an absolute path that exists at runtime and that your application confines file access to. If you leave it unset (or give a relative path), the generated fix is emitted with a placeholder identifier (`MOBB_SET_ALLOWED_BASE_DIR`) that **deliberately does not compile**, so a missing security boundary cannot be overlooked \u2014 replace it with your absolute base directory. A relative path would otherwise resolve against the process working directory (moving the boundary). At runtime the guard aborts (C: `exit(EXIT_FAILURE)`) / throws (C++: `std::runtime_error`) on a path that escapes the base. Pick the narrowest directory that still contains every legitimate file the code opens."
-  }
-};
-
-// src/features/analysis/scm/shared/src/storedQuestionData/cpp/index.ts
-var vulnerabilities11 = {
-  ["CMDi"]: commandInjection,
-  ["PT"]: pathManipulation
-};
-var cpp_default = vulnerabilities11;
-
-// src/features/analysis/scm/shared/src/storedQuestionData/csharp/httpOnlyCookie.ts
-var httpOnlyCookie = {
-  httpOnlyCookie: {
-    content: () => "Is the cookie value supposed to be exposed to client-side scripting code?",
-    description: () => httpOnlyMessage,
-    guidance: () => ""
-  },
-  cookieVarName: {
-    content: () => "Please define a variable name",
-    description: () => `We need a variable for the new cookie instance`,
-    guidance: () => ""
-  }
-};
-var httpOnlyMessage = `\`HttpOnly\` is a security feature for cookies that can be set by a web server 
-      when sending a Set-Cookie header in an HTTP response. When the HTTP Only flag is set for a cookie, it means that the cookie can only 
-      be accessed and modified by the server, and client-side scripts (like JavaScript) running in the browser are not allowed to access the cookie.      
-      
-&nbsp;
-    
-      
-***If your client-site application needs to access the value of this cookie, making this change might break the application logic.***  
-      
-&nbsp;
-
-`;
-
-// src/features/analysis/scm/shared/src/storedQuestionData/csharp/insecureBinderConfiguration.ts
-var insecureBinderConfiguration = {
-  bindAttributeParam: {
-    content: ({ func_param_name }) => `Which properties of the model should be included in model binding for \`${func_param_name}\`?`,
-    description: () => "Provide a comma-separated list of valid property names to be included in model binding. See [the official documentation](https://learn.microsoft.com/en-us/aspnet/core/mvc/models/model-binding?view=aspnetcore-8.0#bind-attribute) for more details.",
-    guidance: () => ""
-  }
-};
-
-// src/features/analysis/scm/shared/src/storedQuestionData/csharp/insecureCookie.ts
-var insecureCookie = {
-  insecureCookie: {
-    content: () => "Will this cookie be used only in encrypted channels (https)?",
-    description: () => `When a cookie is marked as "secure" in a web environment, it means that the cookie should only be sent over secure, encrypted connections, like HTTPS.
-    In environments like local development or test, setting cookies as secure might have some consequences:    
-    
-&nbsp;    
-    - Development Convenience: When developing locally, you might not always have HTTPS set up, as it often involves 
-    additional configuration and certificates. If cookies are marked as secure, 
-    they won't be sent over HTTP, and this could potentially interfere with the normal 
-    functioning of your application during development.    
-    
-&nbsp;    
-    - Testing for Secure Environments: If your application relies on secure cookies, you should ensure that your 
-    testing environment accurately simulates the production environment's security features. 
-    This may involve setting up HTTPS in your local development environment.    
-    
-&nbsp;    
-    - Debugging Challenges: Debugging may be more challenging when using secure cookies in a 
-    development environment, especially if you need to inspect or manipulate the cookies during 
-    development.`,
-    guidance: () => ""
-  },
-  cookieVarName: {
-    content: () => "Please define a variable name",
-    description: () => `We need a variable for the new cookie instance`,
-    guidance: () => ""
-  }
-};
-
-// src/features/analysis/scm/shared/src/storedQuestionData/csharp/insecureRandomness.ts
-var insecureRandomness = {
-  isRandomNumberGeneratorAvailable: {
-    content: () => "We use the `RandomNumberGenerator` class from the `System.Security.Cryptography` package. Does this class exist for the .NET version you use?",
-    description: () => "See [the official documentation](https://learn.microsoft.com/en-us/dotnet/api/system.security.cryptography.randomnumbergenerator?view=net-8.0#applies-to) for more details.",
-    guidance: () => ""
-  },
-  isNetVersionGreaterThan6: {
-    content: () => "We are able to offer a more concise solution if the .NET version is greater then .NET 6",
-    description: () => "",
-    guidance: () => ""
-  }
-};
-
-// src/features/analysis/scm/shared/src/storedQuestionData/csharp/insufficientLogging.ts
-var insufficientLogging = {
-  logMessage: {
-    content: () => "Enter the message that you want to appear in the log",
-    description: () => "",
-    guidance: () => ""
-  }
-};
-
-// src/features/analysis/scm/shared/src/storedQuestionData/csharp/logForging.ts
-var logForging = {
-  isHtmlDisplay: {
-    content: () => "Is the text written to the log going to be displayed as HTML?",
-    description: () => "",
-    guidance: ({ userInputValue }) => {
-      switch (userInputValue) {
-        case "yes":
-          return "We use the `System.Web` `HttpUtility` to decode the HTML";
-        default:
-          return "";
-      }
-    }
-  }
-};
-
-// src/features/analysis/scm/shared/src/storedQuestionData/csharp/overlyBroadCatch.ts
-var overlyBroadCatch = {
-  defaultExceptionsInWhenFilter: {
-    content: () => "Exceptions to filter",
-    description: () => "Coma separated list of the Fully Qualified Exceptions names",
-    guidance: () => ""
-  }
-};
-
-// src/features/analysis/scm/shared/src/storedQuestionData/csharp/pt.ts
-var pt = {
-  taintedTermType: {
-    content: ({ expression }) => `Does \`${expression}\` represent a file name or a file path?`,
-    description: ({ expression }) => `We replace all illegal file name characters for Unix, Windows, and macOS operation systems, including slashes. Ensure that \`${expression}\` isn't supposed to contain slashes or other illegal file name characters.`,
-    guidance: () => ""
-  },
-  pathTargetDir: {
-    content: () => "Allowed file path",
-    description: () => "Provide the intended file path destination eg: /tmp/testfiles/users/",
-    guidance: () => ""
-  }
-};
-
-// src/features/analysis/scm/shared/src/storedQuestionData/csharp/regexMissingTimeout.ts
-var regexMissingTimeout = {
-  netVersionGreaterOrEqual7: {
-    content: () => "Is your target framework .NET 7 or greater?",
-    description: () => "",
-    guidance: () => ""
-  },
-  timeout: {
-    content: () => "Enter the timeout in milliseconds",
-    description: () => "If the limit is reached a RegexTimeoutException is thrown, this could be caused by excessive backtracking",
-    guidance: () => ""
-  },
-  useBacktrackingOption: {
-    content: () => "Use non backtracking option",
-    description: () => "If the regex does not need to use backtracking we can disable it using regex options",
-    guidance: () => ""
-  }
-};
-
-// src/features/analysis/scm/shared/src/storedQuestionData/csharp/requestParametersBoundViaInput.ts
-var requestParametersBoundViaInput = {
-  fieldsToCopy: {
-    content: () => "Please list all the fields you expect as input from the user. Use comma separated list.",
-    description: () => `This is meant to avoid mass assignment vulnerabilities, where the user would enter an inner unexpected field`,
-    guidance: () => ""
-  }
-};
-
-// src/features/analysis/scm/shared/src/storedQuestionData/csharp/sqlInjection.ts
-var sqlInjection = {
-  databaseProvider: {
-    content: () => "Select the database provider",
-    description: () => "",
-    guidance: () => ""
-  }
-};
-
-// src/features/analysis/scm/shared/src/storedQuestionData/csharp/ssrf.ts
-var ssrf2 = {
-  domainsAllowlist: {
-    content: () => "Allowed domains",
-    description: () => "Coma separated list of allowed domains.",
-    guidance: () => ""
-  }
-};
-
-// src/features/analysis/scm/shared/src/storedQuestionData/csharp/sysLeak.ts
-var sysLeak = {
-  errorMessage: {
-    content: () => "Enter the error message that you want to appear in the log",
-    description: () => "",
-    guidance: () => ""
-  },
-  noLoggerAction: {
-    content: () => "Which of the following you want to use instead of the vulnerable code?",
-    description: () => "",
-    guidance: () => ""
-  }
-};
-
-// src/features/analysis/scm/shared/src/storedQuestionData/csharp/trustBoundaryViolation.ts
-var trustBoundaryViolation = {
-  validationPattern: {
-    content: ({ expression }) => `What is the expected type of \`${expression}\`?`,
-    description: () => "We use regex to validate the input to avoid runtime surprises",
-    guidance: () => ""
-  },
-  otherPatternValue: {
-    content: () => `Enter the regex pattern you would like to use to validate the input`,
-    description: () => "See patterns at [the regex docs](https://learn.microsoft.com/en-us/dotnet/standard/base-types/regular-expression-language-quick-reference)",
-    guidance: () => ""
-  }
-};
-
-// src/features/analysis/scm/shared/src/storedQuestionData/csharp/useOfSystemOutputStream.ts
-var useOfSystemOutputStream = {
-  noLoggerAction: {
-    content: () => "Which of the following you want to use instead of the vulnerable code?",
-    description: () => "",
-    guidance: () => ""
-  }
-};
-
-// src/features/analysis/scm/shared/src/storedQuestionData/csharp/valueShadowing.ts
-var valueShadowing = {
-  collectionName: {
-    content: () => "Please select the collection to search/index from",
-    description: () => `Accessing the root object eg Request["item"] searches across all available collections and returns the first item that matches. Potentially leading to the correct value being shadowed. Available collections include:
-    - QueryString: The values of variables in the HTTP query string.
-    - Form: The values of form elements in the HTTP request body.
-    - Cookies: The values of cookies sent in the HTTP request.
-    - ClientCertificate: The values of fields stored in the client certificate that is sent in the HTTP request.
-    - ServerVariables: The values of predetermined environment variables.`,
-    guidance: () => `See 
-    - https://learn.microsoft.com/en-us/previous-versions/iis/6.0-sdk/ms524948(v=vs.90),
-    - https://learn.microsoft.com/en-us/dotnet/api/system.web.httprequest?view=netframework-4.8.1`
-  }
-};
-
-// src/features/analysis/scm/shared/src/storedQuestionData/csharp/wcfMisconfigurationThrottlingNotEnabled.ts
-var wcfMisconfigurationThrottlingNotEnabled = {
-  maxConcurrentCalls: {
-    content: () => "Please define the maximum concurrent calls",
-    description: () => `A positive integer that limits the number of messages that currently process across a ServiceHost. Calls in excess of the limit are queued. Setting this value to 0 is equivalent to setting it to Int32.MaxValue.`,
-    guidance: () => {
-      return "";
-    }
-  },
-  maxConcurrentInstances: {
-    content: () => "Please define the maximum concurrent instances",
-    description: () => `A positive integer that limits the number of InstanceContext objects that execute at one time across a ServiceHost. Requests to create additional instances are queued and complete when a slot below the limit becomes available.`,
-    guidance: () => {
-      return "";
-    }
-  },
-  maxConcurrentSessions: {
-    content: () => "Please define the maximum concurrent sessions",
-    description: () => `A positive integer that limits the number of sessions a ServiceHost object can accept.`,
-    guidance: () => {
-      return "";
-    }
-  }
-};
-
-// src/features/analysis/scm/shared/src/storedQuestionData/csharp/xss.ts
-var xss = {
-  allowSpecialCharacters: {
-    content: ({ source_value }) => `Does your code allow encodable HTML characters like '&', '<', '"' etc. in: \`${source_value}\`?`,
-    description: () => "",
-    guidance: () => ""
-  },
-  containsHtml: {
-    content: ({ prop_value }) => `Does your code allow having HTML tags in: \`${prop_value}\`?`,
-    description: () => "",
-    guidance: () => ""
-  },
-  netVersionGreaterOrEqual45: {
-    content: () => "Is your target framework .NET 4.5 or greater?",
-    description: () => "",
-    guidance: () => ""
-  },
-  useHTML4NamedEntities: {
-    content: () => "Would you like to use HTML 4.0 Named entities?",
-    description: () => "See [examples](https://www.w3schools.com/charsets/ref_html_entities_4.asp) and [full description](https://www.w3.org/TR/WD-html40-970708/sgml/entities.html)",
-    guidance: () => ""
-  }
-};
-
-// src/features/analysis/scm/shared/src/storedQuestionData/csharp/xxe.ts
-var xxe = {
-  netVersionGreaterOrEqual4: {
-    content: () => "Is your target framework .NET 4.0.0 or greater?",
-    description: () => "",
-    guidance: ({ userInputValue }) => {
-      switch (userInputValue) {
-        case "yes":
-          return "We set `DtdProcessing` to `DtdProcessing.Prohibit` in order to prevent DTD parsing.";
-        default:
-          return "We set `ProhibitDtd` to `true` in order to prevent DTD parsing.";
-      }
-    }
-  }
-};
-
-// src/features/analysis/scm/shared/src/storedQuestionData/csharp/index.ts
-var vulnerabilities12 = {
-  ["LOG_FORGING"]: logForging,
-  ["SSRF"]: ssrf2,
-  ["XXE"]: xxe,
-  ["XSS"]: xss,
-  ["USE_OF_SYSTEM_OUTPUT_STREAM"]: useOfSystemOutputStream,
-  ["SYSTEM_INFORMATION_LEAK"]: sysLeak,
-  ["OVERLY_BROAD_CATCH"]: overlyBroadCatch,
-  ["TRUST_BOUNDARY_VIOLATION"]: trustBoundaryViolation,
-  ["PT"]: pt,
-  ["REGEX_MISSING_TIMEOUT"]: regexMissingTimeout,
-  ["HTTP_ONLY_COOKIE"]: httpOnlyCookie,
-  ["INSECURE_COOKIE"]: insecureCookie,
-  ["WCF_MISCONFIGURATION_THROTTLING_NOT_ENABLED"]: wcfMisconfigurationThrottlingNotEnabled,
-  ["INSECURE_BINDER_CONFIGURATION"]: insecureBinderConfiguration,
-  ["VALUE_SHADOWING"]: valueShadowing,
-  ["INSECURE_RANDOMNESS"]: insecureRandomness,
-  ["INSUFFICIENT_LOGGING"]: insufficientLogging,
-  ["SQL_Injection"]: sqlInjection,
-  ["REQUEST_PARAMETERS_BOUND_VIA_INPUT"]: requestParametersBoundViaInput
-};
-var csharp_default2 = vulnerabilities12;
-
-// src/features/analysis/scm/shared/src/storedQuestionData/go/logForging.ts
-var logForging2 = {
-  isHtmlDisplay: {
-    content: () => "Is the text written to the log going to be displayed as HTML?",
-    description: () => "",
-    guidance: () => ""
-  }
-};
-
-// src/features/analysis/scm/shared/src/storedQuestionData/go/missingSslMinversion.ts
-var missingSslMinversion = {
-  minTlsVersion: {
-    content: () => "What is the minimum version of Transport Layer Security (TLS) you allow? Ensure compatibility between the server and clients.",
-    description: () => "",
-    guidance: () => ""
-  }
-};
-
-// src/features/analysis/scm/shared/src/storedQuestionData/go/websocketMissingOriginCheck.ts
-var websocketMissingOriginCheck = {
-  minTlsVersion: {
-    content: () => "Please provide a comma-separated list of valid hosts. This list will serve as an allow list to check the connection `Origin` header.",
-    description: () => "",
-    guidance: () => ""
-  }
-};
-
-// src/features/analysis/scm/shared/src/storedQuestionData/go/index.ts
-var vulnerabilities13 = {
-  ["LOG_FORGING"]: logForging2,
-  ["MISSING_SSL_MINVERSION"]: missingSslMinversion,
-  ["WEBSOCKET_MISSING_ORIGIN_CHECK"]: websocketMissingOriginCheck
-};
-var go_default2 = vulnerabilities13;
-
-// src/features/analysis/scm/shared/src/storedQuestionData/java/commandInjection.ts
-var commandInjection2 = {
-  isUnixShellCommandPart: {
-    content: () => "Is the input part of Unix shell command?",
-    description: () => `For example:
-
-- \`Runtime.getRuntime().exec(new String[] {"/bin/sh", "-c", "ping -t 5 -c 5 " + input});\`
-- \`Runtime.getRuntime().exec(new String[] {"/bin/bash", "-c", "curl " + input + " > file.txt"});\`
-
-Make sure the input is not:
-
-1. An executable name:
-  - \`Runtime.getRuntime().exec(input);\`
-  - \`Runtime.getRuntime().exec(new String[] {"/bin/bash", input});\`
-  - \`Runtime.getRuntime().exec(new String[] {"/bin/sh", "-c", input + " param"});\`
-  - \`Runtime.getRuntime().exec(new String[] {"/bin/bash", "-c", "cat file.txt | " + input});\`
-  - \`Runtime.getRuntime().exec(new String[] {"/usr/bin/git", "--upload-pack", input});\`
-2. A part of non-unix or cross platform shell command:
-  - \`Runtime.getRuntime().exec(new String[] {"cmd.exe", "/c", "ping " + input});\`
-3. A part of programming language code:
-  - \`Runtime.getRuntime().exec(new String[] {"php", "-r", "echo '" + input + "';"});\`
-  - \`Runtime.getRuntime().exec(new String[] {"perl", "-e", "print '" + input + "'"});\``,
-    guidance: () => ""
-  },
-  installApacheCommonsText: {
-    content: () => "Is the Apache Commons library (org.apache.commons) included in your project, if not, can you add it?",
-    description: () => "Apache Commons Text is a library focused on algorithms working on strings.",
-    guidance: ({ userInputValue }) => userInputValue === "yes" ? "To add the library, modify your pom.xml or build.gradle to include the library. You can find the latest version here https://mvnrepository.com/artifact/org.apache.commons/commons-text" : ""
-  },
-  cmdAllowlist: {
-    content: () => "Allowed Commands",
-    description: () => "Make sure that the list of commands is separated by commas.",
-    guidance: () => ""
-  }
-};
-
-// src/features/analysis/scm/shared/src/storedQuestionData/java/confusingNaming.ts
-var confusingNaming = {
-  newFieldName: {
-    content: () => "Rename the existing field",
-    description: () => "",
-    guidance: () => ""
-  }
-};
-
-// src/features/analysis/scm/shared/src/storedQuestionData/java/duplicatedStrings.ts
-var duplicatedStrings = {
-  constantName: {
-    content: () => "New constant name",
-    description: () => "",
-    guidance: () => ""
-  }
-};
-
-// src/features/analysis/scm/shared/src/storedQuestionData/java/erroneousStringCompare.ts
-var erroneousStringCompare = {
-  javaVersionGreaterOrEqual17: {
-    content: () => "Is `java.util.Objects` package available in your runtime?",
-    description: () => "`java.util.Objects` is supported in Java 1.7 or greater.",
-    guidance: () => ""
-  }
-};
-
-// src/features/analysis/scm/shared/src/storedQuestionData/java/errorConditionWithoutAction.ts
-var errorConditionWithoutAction = {
-  errorMessage: {
-    content: () => "Enter the error message that you want to appear in the log",
-    description: () => "",
-    guidance: () => ""
-  }
-};
-
-// src/features/analysis/scm/shared/src/storedQuestionData/java/httpOnlyCookie.ts
-var httpOnlyCookie2 = {
-  httpOnlyCookie: {
-    content: () => "Is the cookie value supposed to be exposed to client-side scripting code?",
-    description: ({ class_name }) => class_name == "Cookie" ? `${httpOnlyMessage2} ${setHttpOnlyMethodMessage}` : httpOnlyMessage2,
-    guidance: () => ""
-  },
-  cookieVarName: {
-    content: () => "Please define a variable name",
-    description: () => `We need a variable for the new cookie instance`,
-    guidance: () => ""
-  }
-};
-var httpOnlyMessage2 = `\`HttpOnly\` is a security feature for cookies that can be set by a web server 
-      when sending a Set-Cookie header in an HTTP response. When the HTTP Only flag is set for a cookie, it means that the cookie can only 
-      be accessed and modified by the server, and client-side scripts (like JavaScript) running in the browser are not allowed to access the cookie.      
-      
-&nbsp;
-    
-      
-***If your client-site application needs to access the value of this cookie, making this change might break the application logic.***  
-      
-&nbsp;
-
-`;
-var setHttpOnlyMethodMessage = `Beware that if your application is using a version of the javax.servlet-api package < 3.0
-      this change will not work since the method "setHttpOnly" is not present in previous of the package.`;
-
-// src/features/analysis/scm/shared/src/storedQuestionData/java/insecureCookie.ts
-var insecureCookie2 = {
-  insecureCookie: {
-    content: () => "Will this cookie be used only in encrypted channels (https)?",
-    description: () => `When a cookie is marked as "secure" in a web environment, it means that the cookie should only be sent over secure, encrypted connections, like HTTPS.
-    In environments like local development or test, setting cookies as secure might have some consequences:    
-    
-&nbsp;    
-    - Development Convenience: When developing locally, you might not always have HTTPS set up, as it often involves 
-    additional configuration and certificates. If cookies are marked as secure, 
-    they won't be sent over HTTP, and this could potentially interfere with the normal 
-    functioning of your application during development.    
-    
-&nbsp;    
-    - Testing for Secure Environments: If your application relies on secure cookies, you should ensure that your 
-    testing environment accurately simulates the production environment's security features. 
-    This may involve setting up HTTPS in your local development environment.    
-    
-&nbsp;    
-    - Debugging Challenges: Debugging may be more challenging when using secure cookies in a 
-    development environment, especially if you need to inspect or manipulate the cookies during 
-    development.`,
-    guidance: () => ""
-  },
-  cookieVarName: {
-    content: () => "Please define a variable name",
-    description: () => `We need a variable for the new cookie instance`,
-    guidance: () => ""
-  }
-};
-
-// src/features/analysis/scm/shared/src/storedQuestionData/java/j2eeGetConnection.ts
-var j2eeGetConnection2 = {
-  jndiResourceName: {
-    content: () => "What JNDI name is the database connection pool registered under?",
-    description: () => 'We need the JNDI name your app server uses to expose its container-managed `DataSource`. The fix performs `new InitialContext().lookup(<jndi-name>)` to retrieve the pool, so this value must exactly match the resource definition (e.g. `<Resource name="...">` in Tomcat `context.xml`, or the binding declared in WildFly / WebSphere / WebLogic). The default `java:comp/env/jdbc/myDataSource` is the canonical Tomcat / Spring convention; replace it with whatever your environment uses.',
-    guidance: () => ""
-  }
-};
-
-// src/features/analysis/scm/shared/src/storedQuestionData/java/leftoverDebugCode.ts
-var leftoverDebugCode = {
-  isCodeUsed: {
-    content: () => "The function seems to be a remnant of debug code. Is it still being used?",
-    description: () => "",
-    guidance: () => ""
-  }
-};
-
-// src/features/analysis/scm/shared/src/storedQuestionData/java/localeDependentComparison.ts
-var localeDependentComparison = {
-  localeType: {
-    content: ({ variable }) => `Is ${variable} locale dependent?`,
-    description: () => `Select "locale insensitive" for string comparisons that are not dependent on the locale.
-
-    Select "default locale" for string comparisons that uses the default locale.
-
-    Select "custom locale" for string comparisons that are dependent on a specific locale language.`,
-    guidance: () => ""
-  },
-  customLocaleLanguage: {
-    content: () => "What is your locale language?",
-    description: () => "A list of locales can be found [here](https://www.oracle.com/java/technologies/javase/jdk8-jre8-suported-locales.html)",
-    guidance: () => ""
-  },
-  customLocaleCountry: {
-    content: () => "What is your locale country?",
-    description: () => "A list of locales can be found [here](https://www.oracle.com/java/technologies/javase/jdk8-jre8-suported-locales.html)",
-    guidance: () => ""
-  }
-};
-
-// src/features/analysis/scm/shared/src/storedQuestionData/java/logForging.ts
-var logForging3 = {
-  isHtmlDisplay: {
-    content: () => "Is the text written to the log going to be displayed as HTML?",
-    description: () => "",
-    guidance: () => ""
-  },
-  htmlEscapingLib: {
-    content: () => "Which HTML escaping library would you like to use?",
-    description: () => `
-  - If you use the Spring framework, you likely already have \`org.springframework.web.util.HtmlUtils\`
-  - Another \`option is org.apache.commons.text.StringEscapeUtils\``,
-    guidance: () => ""
-  }
-};
-
-// src/features/analysis/scm/shared/src/storedQuestionData/java/missingCheckAgainstNull.ts
-var missingCheckAgainstNull = {
-  preferredAction: {
-    content: ({ tainted_expression }) => `What is expected behavior if \`${tainted_expression}\` returns null?`,
-    description: () => "",
-    guidance: () => ""
-  },
-  javaVersionGreaterOrEqual17: {
-    content: () => "Is `java.util.Objects` package available in your runtime?",
-    description: () => "`java.util.Objects` is supported in Java 1.7 or greater.",
-    guidance: () => ""
-  }
-};
-
-// src/features/analysis/scm/shared/src/storedQuestionData/java/openRedirect.ts
-var openRedirect = {
-  allowlist: {
-    content: () => "Allowed domains",
-    description: () => "Add a comma separated list of allowed domains (e.g. 'google.com,example.com')",
-    guidance: () => ""
-  }
-};
-
-// src/features/analysis/scm/shared/src/storedQuestionData/java/overlyBroadCatch.ts
-var overlyBroadCatch2 = {
-  handleRuntimeExceptions: {
-    content: () => "Does the code intentionally catch `RuntimeException` instances like `ArithmeticException` or `NullPointerException` in the `catch` block?",
-    description: () => "Usually, when catching the general `Exception` class catching of `RuntimeException` is implied and not necessarily the wanted/safe behavior. The application needs to deal with it explicitly in a different way, as the Mobb fix suggests.",
-    guidance: () => ""
-  }
-};
-
-// src/features/analysis/scm/shared/src/storedQuestionData/java/privacyViolation.ts
-var privacyViolation = {
-  remediationOption: {
-    content: () => "Preferred fix solution",
-    description: () => `
-      - Completely Remove the log message
-      - Replace the sensitive data with the string [Redacted]
-      - SHA 256 Hash the sensitive information in the log message`,
-    guidance: () => ""
-  }
-};
-
-// src/features/analysis/scm/shared/src/storedQuestionData/java/pt.ts
-var pt2 = {
-  isPathRelativeOnly: {
-    content: ({ expression }) => `Do you expect \`${expression}\` to be a relative path?`,
-    description: () => "You most likely want to serve files relative to the web server's static files folder in web applications. If so, your answer should be `yes`. In CLI applications, you probably would like to give the user more flexibility and allow them to specify absolute paths to any location on the disk \u2013 your answer should be `no` in such cases.",
-    guidance: () => ""
-  },
-  isFileName: {
-    content: ({ expression }) => `Does \`${expression}\` represent a file name or a file name part?`,
-    description: ({ expression }) => `We replace all illegal file name characters for Unix, Windows, and macOS operation systems, including slashes. Ensure that \`${expression}\` isn't supposed to contain slashes or other illegal file name characters. If  \`${expression}\` is supposed to legitimately include such characters, the answer should be "no".`,
-    guidance: () => ""
-  }
-};
-
-// src/features/analysis/scm/shared/src/storedQuestionData/java/relativePathCommand.ts
-var relativePathCommand = {
-  executableLocationPath: {
-    content: () => "What is the absolute path of the directory containing the executable?",
-    description: () => "We need the absolute path to the executable to protect your application from command injection and ensure malicious actors cannot execute arbitrary commands on your system.",
-    guidance: () => ""
-  }
-};
-
-// src/features/analysis/scm/shared/src/storedQuestionData/java/ssrf.ts
-var ssrf3 = {
-  domainsAllowlist: {
-    content: () => "Allowed URL prefixes",
-    description: () => `The security risk of this issue is the ability of an attacker to provide input that shoots HTTP requests from your server to arbitrary URLs, including internal ones, like \`https://admin.mycompany.com\`    
-&nbsp;    
-&nbsp;    To eliminate the risk and fix the issue, check out your app logic and make a whitelist of URLs this API should be allowed to call.`,
-    guidance: () => ""
-  }
-};
-
-// src/features/analysis/scm/shared/src/storedQuestionData/java/sysLeak.ts
-var sysLeak2 = {
-  errorMessage: {
-    content: () => "Enter the error message that you want to appear in the log",
-    description: () => "",
-    guidance: () => ""
-  },
-  noLoggerAction: {
-    content: () => "Which of the following you want to use instead of the vulnerable code?",
-    description: () => "",
-    guidance: () => ""
-  }
-};
-
-// src/features/analysis/scm/shared/src/storedQuestionData/java/trustBoundaryViolation.ts
-var trustBoundaryViolation2 = {
-  validationPattern: {
-    content: ({ expression }) => `What is the expected type of \`${expression}\`?`,
-    description: () => "We use regex to validate the input to avoid runtime surprises",
-    guidance: () => ""
-  },
-  otherPatternValue: {
-    content: () => `Enter the regex pattern you would like to use to validate the input`,
-    description: () => "See patterns at [the regex javadoc](https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/regex/Pattern.html)",
-    guidance: () => ""
-  }
-};
-
-// src/features/analysis/scm/shared/src/storedQuestionData/java/uncheckedLoopCondition.ts
-var uncheckedLoopCondition = {
-  loopLimit: {
-    content: () => "Please define a maximum loop limit",
-    description: () => `Setting this number to a reasonable value will prevent the vulnerability`,
-    guidance: () => ""
-  },
-  varName: {
-    content: () => "Please define a variable name",
-    description: () => `We need to define a variable to be used as a counter to limit the loop`,
-    guidance: () => ""
-  }
-};
-
-// src/features/analysis/scm/shared/src/storedQuestionData/java/unsafeReflection.ts
-var unsafeReflection = {
-  classAllowlist: {
-    content: () => "Allowed class names for reflection",
-    description: () => `Provide a comma-separated list of fully-qualified class names that are permitted to be loaded via reflection (e.g. \`com.example.MyClass\`). Any other class name will be rejected at runtime.`,
-    guidance: () => ""
-  }
-};
-
-// src/features/analysis/scm/shared/src/storedQuestionData/java/useOfSystemOutputStream.ts
-var useOfSystemOutputStream2 = {
-  noLoggerAction: {
-    content: () => "Which of the following you want to use instead of the vulnerable code?",
-    description: () => "",
-    guidance: () => ""
-  }
-};
-
-// src/features/analysis/scm/shared/src/storedQuestionData/java/xss.ts
-var xss2 = {
-  isHtmlOrSafeAttribute: {
-    content: ({ tainted_variable }) => `Where is \`${tainted_variable}\` written to?`,
-    description: () => `Answer examples:
-
-- a text in an HTML tag or a value of a safe HTML attribute:
-    - \`<li><%= name %></li>\`
-    - \`<div>Name: <%= name %></div>\`
-    - \`<input value="<%= name %>" name="name"/>\`
-    - \`<div data-name="<%= name %>"></div>\`
-- a JavaScript code block:
-    - \`<script>const name = "<%= name %>";</script>\`
-- an event attribute of an HTML tag:
-    - \`<a onclick="alert('<%= name %>')">click me</a>\`
-    - \`<img onmouseover="alert('<%= name %>')"/>\`
-- a src-like attribute of an HTML tag:
-    - \`<a href="/user/<%= name %>">me</a>\`
-    - \`<img src="/img/<%= name %>"/>\`
-    - \`<form action="<%= name %>"></form>\`
-    - \`<iframe srcdoc="<%= name %>"/>\`
-- a part of an HTML tag attributes list:
-    - \`<a <%= name %>>text</a>\`
-
-See more details about safe and unsafe HTML attributes:
-- [PortSwigger cheat-sheet](https://portswigger.net/web-security/cross-site-scripting/cheat-sheet)
-- [DOMPurify attributes filter implementation](https://github.com/cure53/DOMPurify/blob/c29aa900a1c286b82ee4f48a7ffab96cab3e84fa/src/attrs.js)
-`,
-    guidance: () => ""
-  },
-  isHtmlEncoded: {
-    content: () => "Is the user input already encoded as HTML text?",
-    description: () => "If you are unsure, we will decode the user input and encode it again to ensure it is safe and the data is kept the same.",
-    guidance: () => ""
-  },
-  htmlEscapingLib: {
-    content: () => "Which HTML escaping library would you like to use?",
-    description: () => `
-  - If you use the Spring framework, you likely already have \`org.springframework.web.util.HtmlUtils\`
-  - Another option is \`org.apache.commons.text.StringEscapeUtils\``,
-    guidance: () => ""
-  }
-};
-
-// src/features/analysis/scm/shared/src/storedQuestionData/java/xxe.ts
-var xxe2 = {
-  factoryVarName: {
-    content: () => "Name the new Factory variable",
-    description: () => "We needed to create a new variable for this fix. We actually like the name we picked, but maybe you follow different naming conventions, so you can change it here.",
-    guidance: () => ""
-  }
-};
-
-// src/features/analysis/scm/shared/src/storedQuestionData/java/index.ts
-var vulnerabilities14 = {
-  ["CMDi_relative_path_command"]: relativePathCommand,
-  ["CMDi"]: commandInjection2,
-  ["CONFUSING_NAMING"]: confusingNaming,
-  ["ERROR_CONDTION_WITHOUT_ACTION"]: errorConditionWithoutAction,
-  ["XXE"]: xxe2,
-  ["XSS"]: xss2,
-  ["PRIVACY_VIOLATION"]: privacyViolation,
-  ["PT"]: pt2,
-  ["SSRF"]: ssrf3,
-  ["LOG_FORGING"]: logForging3,
-  ["LOCALE_DEPENDENT_COMPARISON"]: localeDependentComparison,
-  ["MISSING_CHECK_AGAINST_NULL"]: missingCheckAgainstNull,
-  ["OPEN_REDIRECT"]: openRedirect,
-  ["OVERLY_BROAD_CATCH"]: overlyBroadCatch2,
-  ["SYSTEM_INFORMATION_LEAK"]: sysLeak2,
-  ["USE_OF_SYSTEM_OUTPUT_STREAM"]: useOfSystemOutputStream2,
-  ["HTTP_ONLY_COOKIE"]: httpOnlyCookie2,
-  ["UNCHECKED_LOOP_CONDITION"]: uncheckedLoopCondition,
-  ["INSECURE_COOKIE"]: insecureCookie2,
-  ["TRUST_BOUNDARY_VIOLATION"]: trustBoundaryViolation2,
-  ["UNSAFE_REFLECTION"]: unsafeReflection,
-  ["J2EE_GET_CONNECTION"]: j2eeGetConnection2,
-  ["LEFTOVER_DEBUG_CODE"]: leftoverDebugCode,
-  ["ERRONEOUS_STRING_COMPARE"]: erroneousStringCompare,
-  ["DUPLICATED_STRINGS"]: duplicatedStrings
-};
-var java_default2 = vulnerabilities14;
-
-// src/features/analysis/scm/shared/src/storedQuestionData/python/csrf.ts
-var csrf2 = {
-  isPythonDjangoTemplate: {
-    content: () => "Is the reported file Python Django template?",
-    description: () => "",
-    guidance: () => ""
-  }
-};
-
-// src/features/analysis/scm/shared/src/storedQuestionData/js/commandInjection.ts
-var commandInjection3 = {
-  isCommandExecutable: {
-    content: () => "Commands can be intrinsically unsafe if they call out to other executables or run arbitary code",
-    description: () => `Does the command fall into one of the following categories:
-
-1. An executable name:
-  - \`exec(input);\`
-  - \`exec("/bin/bash " + input);\`
-  - \`exec("/bin/sh -c" + input + " param");\`
-  - \`exec("/bin/bash -c cat file.txt | " + input);\`
-  - \`exec("/usr/bin/git --upload-pack " + input);\`
-2. A part of non-unix or cross platform shell command:
-  - \`exec("cmd.exe /c ping " + input);\`
-3. A part of programming language code:
-  - \`exec("php -r echo '" + input + "';");\`
-  - \`exec("perl -e print '" + input + "'");\``,
-    guidance: () => ""
-  }
-};
-
-// src/features/analysis/scm/shared/src/storedQuestionData/js/graphqlDepthLimit.ts
-var graphqlDepthLimit = {
-  depthLimit: {
-    content: () => "Please define a maximum query depth",
-    description: () => `Setting this number to a reasonable value will prevent the attack.
-Make sure to pick a value large enough to allowed the nessecary amount of nested queries.`,
-    guidance: () => {
-      return "We use `graphql-depth-limit` npm package to limit the depth of nested queries. Please make sure you install the package using `npm install graphql-depth-limit`.";
-    }
-  }
-};
-
-// src/features/analysis/scm/shared/src/storedQuestionData/js/hardcodedDomainInHtml.ts
-var hardcodedDomainInHtml = {
-  isCDNFixedVersion: {
-    content: ({ url }) => `Does the content of \`${url}\` change over time? If it does, we can't offer this fix.`,
-    description: () => "You need to make sure the content of the file you are loading from the external source is persistent. To guarantee the integrity hash does not change over time, please make sure you use a proper CDN and version of the script you are loading is pinned.",
-    guidance: () => ""
-  }
-};
-
-// src/features/analysis/scm/shared/src/storedQuestionData/js/hardcodedSecrets.ts
-var hardcodedSecrets2 = {
-  envVarName: {
-    content: () => "Please define an environment variable name",
-    description: () => `We will use this environment variable instead of the hardcoded secret`,
-    guidance: () => ""
-  },
-  keepAsDefault: {
-    content: () => "Do you want to keep the hardcoded secret in the code for now?",
-    description: () => 'Answer "yes" if you cannot set the environment variable in all environments right away.',
-    guidance: () => ""
-  }
-};
-
-// src/features/analysis/scm/shared/src/storedQuestionData/js/iframeWithoutSandbox.ts
-var iframeWithoutSandbox = {
-  iframeRestrictions: {
-    content: () => "Please define a comma-separated list of iframe sandbox restrictions (optional)",
-    description: () => `Possible values:
-- allow-downloads
-- allow-forms
-- allow-modals
-- allow-orientation-lock
-- allow-pointer-lock
-- allow-popups
-- allow-popups-to-escape-sandbox
-- allow-presentation
-- allow-same-origin
-- allow-scripts
-- allow-storage-access-by-user-activation
-- allow-top-navigation
-- allow-top-navigation-by-user-activation
-- allow-top-navigation-to-custom-protocols
-
-See more info [here](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/iframe#sandbox).`,
-    guidance: () => ""
-  }
-};
-
-// src/features/analysis/scm/shared/src/storedQuestionData/js/incompleteUrlSanitization.ts
-var incompleteUrlSanitization = {
-  allowedRootDomain: {
-    content: () => "The root domain of your application",
-    description: () => "We needed to strengthen the security check by ensuring that the url is under the root domain of your application.",
-    guidance: () => ""
-  }
-};
-
-// src/features/analysis/scm/shared/src/storedQuestionData/js/insecureRandomness.ts
-var insecureRandomness2 = {
-  isGetRandomValuesSupported: {
-    content: () => "Is getRandomValues() function supported by your JavaScript engine?",
-    description: () => "[getRandomValues()](https://developer.mozilla.org/en-US/docs/Web/API/Crypto/getRandomValues) is supported by [more than 97% of browsers](https://caniuse.com/?search=getRandomValues) and [Node.js >= 15.0.0](https://nodejs.org/api/webcrypto.html#cryptogetrandomvaluestypedarray).",
-    guidance: () => ""
-  }
-};
-
-// src/features/analysis/scm/shared/src/storedQuestionData/js/logForging.ts
-var logForging4 = {
-  isHtmlDisplay: {
-    content: () => "Is the text written to the log going to be displayed as HTML?",
-    description: () => "",
-    guidance: () => ""
-  }
-};
-
-// src/features/analysis/scm/shared/src/storedQuestionData/js/missingCSPHeader.ts
-var cspHeaderValue = {
-  cspHeaderValue: {
-    content: () => "Please provide the value for the Content-Security-Policy header",
-    description: () => `The Content-Security-Policy (CSP) header is a critical security measure that helps protect websites from various attacks, particularly Cross-Site Scripting (XSS) and other code injection attacks. Here's a concise explanation:
-    
-&nbsp;    
-&nbsp;
-    **What it does**:
-    
-&nbsp;    
-&nbsp;
-    CSP lets you specify which content sources the browser should consider valid, essentially creating a whitelist of trusted content. It controls things like:
-    
-&nbsp;    
-&nbsp;
-    - Which scripts can execute.    
-&nbsp;    - Where images can be loaded from.    
-&nbsp;    - Which styles can be applied.    
-&nbsp;    - Which forms can be submitted to.    
-&nbsp;    - What domains can be connected to.    
-&nbsp;    
-&nbsp;    Default value explanation:    
-&nbsp;    
-&nbsp;    - default-src 'self: Only allows resources from the same origin by default.    
-&nbsp;    - script-src 'self': Only allows scripts to be loaded from the same origin.    
-&nbsp;    - style-src 'self': Only allows styles from the same origin.    
-&nbsp;    - object-src 'none': Disallows <object>, <embed>, and <applet> elements.    
-&nbsp;    - base-uri 'self': Restricts where the <base> tag can point to.    
-&nbsp;    - frame-ancestors 'self': Ensures that only the same origin can embed the page using an iframe.
-    
-&nbsp;    
-&nbsp;    **This kind of \`CSP\` is more secure but may require adjustments for your specific application, especially if you need to load resources from external domains or use inline scripts/styles.**`,
-    guidance: () => ``
-  }
-};
-
-// src/features/analysis/scm/shared/src/storedQuestionData/js/missingHSTSHeader.ts
-var headerMaxAge = {
-  headerMaxAge: {
-    content: () => "Please provide the maximum age of the header",
-    description: () => `This is the time, in seconds, that the browser should remember that the site is only to be accessed using \`HTTPS\`.    
-&nbsp;    
-&nbsp; 
-    Setting the \`max-age\` to \`0\` (over an https connection) will immediately expire the Strict-Transport-Security header, allowing access via \`HTTP\`.
-
-    
-&nbsp;    
-&nbsp;
-    The HTTP Strict-Transport-Security response header (\`HSTS\`) informs browsers that the site 
-    should only be accessed using HTTPS, and that any future attempts to access it using HTTP should automatically 
-    be converted to HTTPS.
-
-    
-&nbsp;    
-&nbsp;
-    If a website accepts a connection through \`HTTP\` and redirects to \`HTTPS\`, visitors may initially communicate with 
-    the non-encrypted version of the site before being redirected, if, for example, the visitor 
-    types \`http://www.example.com\` or even just \`example.com\`. This creates an opportunity for a man-in-the-middle attack. 
-    The redirect could be exploited to direct visitors to a malicious site instead of the secure version of the original site.
-    
-&nbsp;    
-&nbsp;
-    The \`HTTP\` Strict Transport Security header informs the browser that it should never load a site using \`HTTP\` 
-    and should automatically convert all attempts to access the site using \`HTTP\` to \`HTTPS\` requests instead.`,
-    guidance: () => ``
-  }
-};
-
-// src/features/analysis/scm/shared/src/storedQuestionData/js/missingXFrameOptions.ts
-var xFrameOptionsValue = {
-  xFrameOptionsValue: {
-    content: () => "Please provide the value for the X-Frame-Options header",
-    description: () => `The \`X-Frame-Options\` HTTP response header tells the browser whether the page is allowed to be rendered inside a \`<frame>\`, \`<iframe>\`, \`<embed>\` or \`<object>\`. Without it, attackers can embed your application in an invisible iframe and trick users into clicking on it \u2014 a class of attacks known as clickjacking (UI redressing).    
-&nbsp;    
-&nbsp;    **Allowed values:**    
-&nbsp;    - \`DENY\` \u2014 the page cannot be framed by any site, including your own. Recommended default for any page that does not need to be embedded.    
-&nbsp;    - \`SAMEORIGIN\` \u2014 the page can only be framed by pages served from the same origin. Use this only if your own application legitimately embeds this page in an iframe.`,
-    guidance: () => ``
-  }
-};
-
-// src/features/analysis/scm/shared/src/storedQuestionData/js/noLimitsOrThrottling.ts
-var noLimitsOrThrottling2 = {
-  setGlobalLimiter: {
-    content: () => "Would you like to use a global rate limit for all your endpoints within the same file?",
-    description: () => "",
-    guidance: () => ""
-  }
-};
-
-// src/features/analysis/scm/shared/src/storedQuestionData/js/openRedirect.ts
-var openRedirect2 = {
-  isExternal: {
-    content: () => "Does the redirect go to an external site?",
-    description: () => "",
-    guidance: () => ""
-  },
-  domainAllowlist: {
-    content: () => "Allowed domains names",
-    description: () => "please provide a coma separated list of allowed domains names (example.com, example.org, etc.)",
-    guidance: () => ""
-  },
-  pathAllowlist: {
-    content: () => "Allowed paths (URIs)",
-    description: () => "please provide a coma separated list of allowed path (/health, /api/v1/health, etc.)",
-    guidance: () => ""
-  },
-  includeProtocolValidation: {
-    content: () => "Should HTTP or HTTPS protocol be enforced?",
-    description: () => "please indicate if the protocol should be enforced",
-    guidance: () => ""
-  }
-};
-
-// src/features/analysis/scm/shared/src/storedQuestionData/js/pt.ts
-var pt3 = {
-  taintedTermType: {
-    content: ({ expression }) => `Does \`${expression}\` represent a file name, a relative path or an absolute path?`,
-    description: ({ expression }) => `We replace all illegal file name characters for Unix, Windows, and macOS operation systems, including slashes. Ensure that \`${expression}\` isn't supposed to contain slashes or other illegal file name characters.`,
-    guidance: () => ""
-  }
-};
-
-// src/features/analysis/scm/shared/src/storedQuestionData/js/ssrf.ts
-var ssrf4 = {
-  domainsAllowlist: {
-    content: () => "List of allowed domain names",
-    description: () => `The security risk of this issue is the ability of an attacker to provide input that shoots HTTP requests from your server to arbitrary domains.
-    
-&nbsp;    
-&nbsp;    To eliminate the risk and fix the issue, check out your app logic and make a whitelist of domains the server should be allowed to call.`,
-    guidance: () => ""
-  }
-};
-
-// src/features/analysis/scm/shared/src/storedQuestionData/js/sysLeak.ts
-var sysLeak3 = {
-  errorMessage: {
-    content: () => "Enter the error message that you want to appear in the log",
-    description: () => "",
-    guidance: () => ""
-  },
-  noLoggerAction: {
-    content: () => "Which of the following you want to use instead of the vulnerable code?",
-    description: () => "",
-    guidance: () => ""
-  }
-};
-
-// src/features/analysis/scm/shared/src/storedQuestionData/js/sysLeakExternal.ts
-var sysLeakExternal = {
-  errorMessage: {
-    content: () => "Enter the error message that you want to appear to the user",
-    description: () => "",
-    guidance: () => ""
+  error: async (message, data) => {
+    const logger3 = await createContextLogger();
+    return logger3.error(message, data);
   }
 };
 
-// src/features/analysis/scm/shared/src/storedQuestionData/js/typeConfusion.ts
-var typeConfusion = {
-  argumentType: {
-    content: () => "What is the type of the HTTP argument?",
-    description: () => "What is the type of the HTTP argument?",
-    guidance: () => ""
+// src/features/analysis/scm/errors.ts
+var InvalidAccessTokenError = class extends Error {
+  constructor(m, scmType) {
+    super(m);
+    this.scmType = scmType;
   }
 };
-
-// src/features/analysis/scm/shared/src/storedQuestionData/js/uncheckedLoopCondition.ts
-var uncheckedLoopCondition2 = {
-  loopLimit: {
-    content: () => "Please define a maximum loop limit",
-    description: () => `Setting this number to a reasonable value will prevent the vulnerability`,
-    guidance: () => ""
-  },
-  varName: {
-    content: () => "Please define a variable name",
-    description: () => `We need to define a variable to be used as a counter to limit the loop`,
-    guidance: () => ""
+var InvalidUrlPatternError = class extends Error {
+  constructor(m, scmType) {
+    super(m);
+    this.scmType = scmType;
   }
 };
-
-// src/features/analysis/scm/shared/src/storedQuestionData/js/xss.ts
-var xss3 = {
-  containsHtml: {
-    content: () => "Does the element or variable contain HTML formatting",
-    description: () => "",
-    guidance: () => ""
-  },
-  isParamTypeString: {
-    content: () => "Is the parameter passed to the $() function a string",
-    description: () => "",
-    guidance: () => ""
-  },
-  isSanitized: {
-    content: ({ expression }) => `Is the expression \`${expression}\` supposed to be not sanitized in this context?`,
-    description: () => "You are using unsafe string substitution in the template. This means that if the expression can contain maliciously crafted data, it may lead to XSS injection. To apply the fix, you have to make sure the expression is not sanitized on the backend already, and it does not represent an HTML code block.",
-    guidance: () => ""
-  },
-  isServerSideCode: {
-    content: () => "Is this code running on the server side (a NodeJS application)",
-    description: () => "The fix to this vulnerability is different is the code runs in the client (browser) or the server side (NodeJs)",
-    guidance: () => ""
+var RefNotFoundError = class extends Error {
+  constructor(m) {
+    super(m);
   }
 };
-
-// src/features/analysis/scm/shared/src/storedQuestionData/js/index.ts
-var vulnerabilities15 = {
-  ["CMDi"]: commandInjection3,
-  ["GRAPHQL_DEPTH_LIMIT"]: graphqlDepthLimit,
-  ["INSECURE_RANDOMNESS"]: insecureRandomness2,
-  ["SSRF"]: ssrf4,
-  ["TYPE_CONFUSION"]: typeConfusion,
-  ["INCOMPLETE_URL_SANITIZATION"]: incompleteUrlSanitization,
-  ["LOG_FORGING"]: logForging4,
-  ["XSS"]: xss3,
-  ["OPEN_REDIRECT"]: openRedirect2,
-  ["SYSTEM_INFORMATION_LEAK"]: sysLeak3,
-  ["SYSTEM_INFORMATION_LEAK_EXTERNAL"]: sysLeakExternal,
-  ["IFRAME_WITHOUT_SANDBOX"]: iframeWithoutSandbox,
-  ["PT"]: pt3,
-  ["HARDCODED_SECRETS"]: hardcodedSecrets2,
-  ["MISSING_HSTS_HEADER"]: headerMaxAge,
-  ["UNCHECKED_LOOP_CONDITION"]: uncheckedLoopCondition2,
-  ["NO_LIMITS_OR_THROTTLING"]: noLimitsOrThrottling2,
-  ["MISSING_CSP_HEADER"]: cspHeaderValue,
-  ["MISSING_X_FRAME_OPTIONS"]: xFrameOptionsValue,
-  ["HARDCODED_DOMAIN_IN_HTML"]: hardcodedDomainInHtml,
-  ["CSRF"]: csrf2
-};
-var js_default = vulnerabilities15;
-
-// src/features/analysis/scm/shared/src/storedQuestionData/python/duplicatedStrings.ts
-var duplicatedStrings2 = {
-  constantName: {
-    content: () => "New constant name",
-    description: () => "",
-    guidance: () => ""
+var ScmBadCredentialsError = class extends Error {
+  constructor(m, scmType) {
+    super(m);
+    this.scmType = scmType;
   }
 };
-
-// src/features/analysis/scm/shared/src/storedQuestionData/python/logForging.ts
-var logForging5 = {
-  isHtmlDisplay: {
-    content: () => "Is the text written to the log going to be displayed as HTML?",
-    description: () => "",
-    guidance: ({ userInputValue }) => {
-      switch (userInputValue) {
-        case "yes":
-          return "We use `html.escape` to decode the HTML";
-        default:
-          return "";
-      }
-    }
+var InvalidRepoUrlError = class extends Error {
+  constructor(m, scmType) {
+    super(m);
+    this.scmType = scmType;
   }
 };
-
-// src/features/analysis/scm/shared/src/storedQuestionData/python/missingEncoding.ts
-var missingEncoding = {
-  fEncoding: {
-    content: () => "Enter the encoding of the file",
-    description: () => "",
-    guidance: () => ""
+var RepoNoTokenAccessError = class extends Error {
+  constructor(m, scmType) {
+    super(m);
+    this.scmType = scmType;
   }
 };
-
-// src/features/analysis/scm/shared/src/storedQuestionData/python/openRedirect.ts
-var openRedirect3 = {
-  allowed_hosts: {
-    content: () => "Allowed domains/paths",
-    description: () => "If external, provide a coma separated list of allowed domains. If internal, provide a coma seperated list of allowed paths",
-    guidance: () => ""
+var RateLimitError = class extends Error {
+  constructor(m, scmType, retryAfter) {
+    super(m);
+    this.scmType = scmType;
+    this.retryAfter = retryAfter;
   }
 };
-
-// src/features/analysis/scm/shared/src/storedQuestionData/python/ssrf.ts
-var ssrf5 = {
-  domainsAllowlist: {
-    content: () => "Allowed URL prefixes",
-    description: () => `The security risk of this issue is the ability of an attacker to provide input that shoots HTTP requests from your server to arbitrary URLs, including internal ones, like \`https://admin.mycompany.com\`    
-&nbsp;    
-&nbsp;    To eliminate the risk and fix the issue, check out your app logic and make a whitelist of URLs this API should be allowed to call.`,
-    guidance: () => ""
+var NetworkError = class extends Error {
+  constructor(m, scmType, errorCode) {
+    super(m);
+    this.scmType = scmType;
+    this.errorCode = errorCode;
   }
 };
 
-// src/features/analysis/scm/shared/src/storedQuestionData/python/uncheckedLoopCondition.ts
-var uncheckedLoopCondition3 = {
-  loopLimit: {
-    content: () => "Please define a maximum loop limit",
-    description: () => `Setting this number to a reasonable value will prevent the vulnerability`,
-    guidance: () => ""
-  },
-  varName: {
-    content: () => "Please define a variable name",
-    description: () => `We need to define a variable to be used as a counter to limit the loop`,
-    guidance: () => ""
-  }
-};
+// src/features/analysis/scm/utils/index.ts
+import { z as z10 } from "zod";
 
-// src/features/analysis/scm/shared/src/storedQuestionData/python/index.ts
-var vulnerabilities16 = {
-  ["CSRF"]: csrf2,
-  ["LOG_FORGING"]: logForging5,
-  ["OPEN_REDIRECT"]: openRedirect3,
-  ["UNCHECKED_LOOP_CONDITION"]: uncheckedLoopCondition3,
-  ["DUPLICATED_STRINGS"]: duplicatedStrings2,
-  ["MISSING_ENCODING_FILE_OPEN"]: missingEncoding,
-  ["SSRF"]: ssrf5
+// src/features/analysis/scm/shared/src/commitDescriptionMarkup.ts
+init_client_generates();
+init_getIssueType();
+init_issueTypeCatalog();
+function capitalizeFirstLetter(str) {
+  return str?.length ? str[0].toUpperCase() + str.slice(1) : "";
+}
+function lowercaseFirstLetter(str) {
+  if (!str) return str;
+  return `${str.charAt(0).toLowerCase()}${str.slice(1)}`;
+}
+var severityToEmoji = {
+  ["critical" /* Critical */]: "\u{1F6A8}",
+  ["high" /* High */]: "\u{1F6A9}",
+  ["medium" /* Medium */]: "\u{1F7E1}",
+  ["low" /* Low */]: "\u{1F7E2}"
 };
-var python_default2 = vulnerabilities16;
+var getCommitDescription = ({
+  vendor,
+  issueType,
+  severity,
+  guidances,
+  fixUrl,
+  irrelevantIssueWithTags
+}) => {
+  const issueTypeString = getIssueTypeFriendlyString(issueType);
+  let description = `This change fixes a **${severity} severity** (${severityToEmoji[severity]}) **${issueTypeString}** issue reported by **${capitalizeFirstLetter(
+    vendor
+  )}**.
 
-// src/features/analysis/scm/shared/src/storedQuestionData/xml/unboundedOccurrences.ts
-var unboundedOccurrences = {
-  maxOccursLimit: {
-    content: () => "The number of allowed repetitions of the element.",
-    description: () => "",
-    guidance: () => `Setting this number to a reasonable value will prevent the attack. 
-A value too low will prevent valid XMLs from being processed. 
-A value too high will cause performance issues up to and including denial of service.`
-  }
-};
+`;
+  if (issueType) {
+    if (irrelevantIssueWithTags?.[0]?.tag) {
+      description += `
+> [!tip]
+> This issue was found to be irrelevant to your project - ${lowercaseFirstLetter(getTagTooltip(irrelevantIssueWithTags[0].tag))}.
+> Mobb recommends to ignore this issue, however fix is available if you think differently. 
 
-// src/features/analysis/scm/shared/src/storedQuestionData/xml/index.ts
-var vulnerabilities17 = {
-  ["WEAK_XML_SCHEMA_UNBOUNDED_OCCURRENCES"]: unboundedOccurrences
-};
-var xml_default2 = vulnerabilities17;
 
-// src/features/analysis/scm/shared/src/storedQuestionData/yaml/noNewPrivileges.ts
-var noNewPrivileges = {
-  requireNewPrivileges: {
-    content: () => "Does the container require new privileges?",
-    description: () => "",
-    guidance: () => `If the container requires new privileges, setting the no-new-privileges option might harm the container functionality.`
+## Justification
+${issueDescription[irrelevantIssueWithTags[0].tag]}
+`;
+    }
+    const catalogEntry = getIssueTypeCatalogEntry(issueType);
+    if (catalogEntry?.issueDescription) {
+      description += `## Issue description
+${catalogEntry.issueDescription}
+`;
+      if (catalogEntry.fixInstructions) {
+        description += `
+## Fix instructions
+${catalogEntry.fixInstructions}
+`;
+      }
+    }
   }
-};
-
-// src/features/analysis/scm/shared/src/storedQuestionData/yaml/portAllInterfaces.ts
-var portAllInterfaces = {
-  trustedIP: {
-    content: () => "Enter trusted Network IP",
-    description: () => "",
-    guidance: () => `Properly set this value to prevent access from untrusted network adapters. Setting this to a wrong value would prevent accessing the container and might break the system.`
+  description += `
+${guidances.map(({ guidance }) => `## Additional actions required
+ ${guidance}
+`).join("")}
+`;
+  if (fixUrl) {
+    description += `
+[More info and fix customization are available in the Mobb platform](${fixUrl})`;
   }
+  return description;
 };
+var getCommitIssueDescription = ({
+  vendor,
+  issueType,
+  irrelevantIssueWithTags,
+  fpDescription,
+  unfixableDescription
+}) => {
+  const issueTypeString = getIssueTypeFriendlyString(issueType);
+  let description = `The following issues reported by ${capitalizeFirstLetter(vendor)} on this PR were found to be irrelevant to your project:
+`;
+  if (issueType) {
+    if (irrelevantIssueWithTags?.[0]?.tag) {
+      description = `
+> [!tip]
+> The following issues reported by ${capitalizeFirstLetter(vendor)} on this PR were found to be irrelevant to your project:
+> ${issueTypeString} - ${lowercaseFirstLetter(getTagTooltip(irrelevantIssueWithTags[0].tag))}.
+> Mobb recommends to ignore this issue, however fix is available if you think differently. 
 
-// src/features/analysis/scm/shared/src/storedQuestionData/yaml/writableFilesystemService.ts
-var writableFilesystemService = {
-  requireWriteAccess: {
-    content: () => "Does the container require writable filesystem access?",
-    description: () => "",
-    guidance: () => `If the container requires writable filesystem access, setting the filesystem as readonly might harm the container functionality.`
-  }
-};
 
-// src/features/analysis/scm/shared/src/storedQuestionData/yaml/index.ts
-var vulnerabilities18 = {
-  ["PORT_ALL_INTERFACES"]: portAllInterfaces,
-  ["WRITABLE_FILESYSTEM_SERVICE"]: writableFilesystemService,
-  ["NO_NEW_PRIVILEGES"]: noNewPrivileges
+## Justification
+${fpDescription ?? unfixableDescription ?? issueDescription[irrelevantIssueWithTags[0].tag]}
+`;
+    }
+    const catalogEntry = getIssueTypeCatalogEntry(issueType);
+    if (catalogEntry?.issueDescription) {
+      description += `## Issue description
+${catalogEntry.issueDescription}
+`;
+    }
+  }
+  return description;
 };
-var yaml_default = vulnerabilities18;
 
-// src/features/analysis/scm/shared/src/storedQuestionData/index.ts
-var StoredQuestionDataItemZ = z3.object({
-  content: z3.function().args(z3.any()).returns(z3.string()),
-  description: z3.function().args(z3.any()).returns(z3.string()),
-  guidance: z3.function().args(z3.any()).returns(z3.string())
-});
-var languages2 = {
-  ["Java" /* Java */]: java_default2,
-  ["JavaScript" /* JavaScript */]: js_default,
-  ["XML" /* Xml */]: xml_default2,
-  ["CSharp" /* CSharp */]: csharp_default2,
-  ["Python" /* Python */]: python_default2,
-  ["Go" /* Go */]: go_default2,
-  ["Cpp" /* Cpp */]: cpp_default,
-  ["YAML" /* Yaml */]: yaml_default
-};
-var storedQuestionData_default = languages2;
+// src/features/analysis/scm/shared/src/index.ts
+init_getIssueType();
 
 // src/features/analysis/scm/shared/src/guidances.ts
+init_client_generates();
 function toQuestion(userInput) {
   const { key, defaultValue } = userInput;
   const value = userInput.value || defaultValue;
   return { ...userInput, defaultValue, value, key, error: false };
 }
-function getQuestionInformation({
-  fixQuestionData,
-  issueType,
-  language
-}) {
-  const { name, content, description, guidance } = fixQuestionData;
-  const storedQuestionDataItem = storedQuestionData_default[language]?.[issueType]?.[name] ?? {
-    content: () => "",
-    description: () => "",
-    guidance: () => ""
-  };
-  const stored = StoredQuestionDataItemZ.parse(storedQuestionDataItem);
-  return {
-    content: (args) => content || stored.content(args),
-    description: (args) => description || stored.description(args),
-    guidance: (args) => guidance || stored.guidance(args)
-  };
-}
-function curriedQuestionInformationByQuestion({
-  issueType,
-  language
-}) {
-  return (fixQuestionData) => getQuestionInformation({
-    issueType,
-    language,
-    fixQuestionData
-  });
-}
 function getPackageFixGuidance(actionsRequired) {
   const actionRequiredStrings = actionsRequired.map((action) => {
     if (action.language === "JS" /* Js */) {
@@ -6045,64 +4467,20 @@ function getPackageFixGuidance(actionsRequired) {
   return actionRequiredStrings.filter((action) => !!action);
 }
 function getFixGuidances({
-  issueType,
-  issueLanguage,
-  fixExtraContext,
-  questions
+  fixExtraContext
 }) {
-  const storedFixGuidanceDataItem = languages[issueLanguage || ""]?.[issueType || ""] ?? {};
-  const storeFixResult = StoredFixDataItemZ.safeParse(storedFixGuidanceDataItem);
   const libGuidances = getPackageFixGuidance(
     fixExtraContext.manifestActionsRequired
   );
-  const extraContext = fixExtraContext.extraContext.reduce(
-    (acc, obj) => {
-      acc[obj.key] = obj.value;
-      return acc;
-    },
-    {}
-  );
   const servedFixGuidances = fixExtraContext.guidances ?? [];
-  const fixGuidance = servedFixGuidances.length > 0 ? servedFixGuidances : storeFixResult.success ? [storeFixResult.data.guidance({ questions, ...extraContext })] : [];
-  return libGuidances.concat(fixGuidance).filter((guidance) => !!guidance);
+  return libGuidances.concat(servedFixGuidances).filter((guidance) => !!guidance);
 }
-var IssueTypeAndLanguageZ = z4.object({
-  issueType: SafeIssueTypeStringZ,
-  issueLanguage: z4.nativeEnum(IssueLanguage_Enum)
-});
 function getGuidances(args) {
-  const safeIssueTypeAndLanguage = IssueTypeAndLanguageZ.safeParse({
-    issueType: args.issueType,
-    issueLanguage: args.issueLanguage
-  });
-  if (!safeIssueTypeAndLanguage.success) {
-    return [];
-  }
   const { questions, fixExtraContext } = args;
-  const { issueType, issueLanguage } = safeIssueTypeAndLanguage.data;
-  const fixGuidances = getFixGuidances({
-    issueType,
-    issueLanguage,
-    fixExtraContext,
-    questions
-  }).map((guidance, index) => ({ guidance, key: `fixGuidance_index_${index}` }));
-  return questions.map((question) => {
-    let questionGuidance = question.guidance;
-    if (!questionGuidance && issueType && issueLanguage) {
-      const getFixInformation = curriedQuestionInformationByQuestion({
-        issueType,
-        language: issueLanguage
-      });
-      const { guidance } = getFixInformation(question);
-      questionGuidance = guidance({
-        userInputValue: question.value
-      });
-    }
-    return {
-      ...question,
-      guidance: questionGuidance
-    };
-  }).filter(({ guidance }) => !!guidance).map(({ guidance, key }) => ({ guidance, key })).concat(fixGuidances);
+  const fixGuidances = getFixGuidances({ fixExtraContext }).map(
+    (guidance, index) => ({ guidance, key: `fixGuidance_index_${index}` })
+  );
+  return questions.map((question) => ({ guidance: question.guidance, key: question.key })).filter(({ guidance }) => !!guidance).concat(fixGuidances);
 }
 
 // src/features/analysis/scm/shared/src/index.ts
@@ -6134,19 +4512,19 @@ function getIssueUrl({
 init_validations();
 
 // src/features/analysis/scm/types.ts
-import { z as z12 } from "zod";
+import { z as z9 } from "zod";
 var ReferenceType = /* @__PURE__ */ ((ReferenceType2) => {
   ReferenceType2["BRANCH"] = "BRANCH";
   ReferenceType2["COMMIT"] = "COMMIT";
   ReferenceType2["TAG"] = "TAG";
   return ReferenceType2;
 })(ReferenceType || {});
-var GithubFullShaZ = z12.string().regex(/^[a-f0-9]{40}$/);
-var MergedPrSurvivalMetadataZ = z12.object({
-  mergeCommitShas: z12.array(GithubFullShaZ).min(1).refine((shas) => new Set(shas).size === shas.length, {
+var GithubFullShaZ = z9.string().regex(/^[a-f0-9]{40}$/);
+var MergedPrSurvivalMetadataZ = z9.object({
+  mergeCommitShas: z9.array(GithubFullShaZ).min(1).refine((shas) => new Set(shas).size === shas.length, {
     message: "mergeCommitShas must contain unique SHAs"
   }),
-  targetBranch: z12.string().min(1)
+  targetBranch: z9.string().min(1)
 });
 var ScmLibScmType = /* @__PURE__ */ ((ScmLibScmType2) => {
   ScmLibScmType2["GITHUB"] = "GITHUB";
@@ -6173,10 +4551,10 @@ var scmTypeToScmLibScmType = {
   ["Ado" /* Ado */]: "ADO" /* ADO */,
   ["Bitbucket" /* Bitbucket */]: "BITBUCKET" /* BITBUCKET */
 };
-var GetReferenceResultZ = z12.object({
-  date: z12.date().optional(),
-  sha: z12.string(),
-  type: z12.nativeEnum(ReferenceType)
+var GetReferenceResultZ = z9.object({
+  date: z9.date().optional(),
+  sha: z9.string(),
+  type: z9.nativeEnum(ReferenceType)
 });
 
 // src/features/analysis/scm/utils/scm.ts
@@ -6323,7 +4701,7 @@ function shouldValidateUrl(repoUrl) {
   return repoUrl && isUrlHasPath(repoUrl);
 }
 function isBrokerUrl(url) {
-  return z13.string().uuid().safeParse(new URL(url).host).success;
+  return z10.string().uuid().safeParse(new URL(url).host).success;
 }
 function buildAuthorizedRepoUrl(args) {
   const { url, username, password } = args;
@@ -6359,7 +4737,7 @@ function getCloudScmLibTypeFromUrl(url) {
   return void 0;
 }
 function getScmLibTypeFromScmType(scmType) {
-  const parsedScmType = z13.nativeEnum(ScmType).parse(scmType);
+  const parsedScmType = z10.nativeEnum(ScmType).parse(scmType);
   return scmTypeToScmLibScmType[parsedScmType];
 }
 function getScmConfig({
@@ -6427,39 +4805,39 @@ init_env();
 import querystring from "querystring";
 import * as api from "azure-devops-node-api";
 import Debug from "debug";
-import { z as z16 } from "zod";
+import { z as z13 } from "zod";
 
 // src/features/analysis/scm/ado/validation.ts
-import { z as z15 } from "zod";
-var ValidPullRequestStatusZ = z15.union([
-  z15.literal(1 /* Active */),
-  z15.literal(2 /* Abandoned */),
-  z15.literal(3 /* Completed */)
+import { z as z12 } from "zod";
+var ValidPullRequestStatusZ = z12.union([
+  z12.literal(1 /* Active */),
+  z12.literal(2 /* Abandoned */),
+  z12.literal(3 /* Completed */)
 ]);
-var AdoAuthResultZ = z15.object({
-  access_token: z15.string().min(1),
-  token_type: z15.string().min(1),
-  refresh_token: z15.string().min(1)
+var AdoAuthResultZ = z12.object({
+  access_token: z12.string().min(1),
+  token_type: z12.string().min(1),
+  refresh_token: z12.string().min(1)
 });
 var AdoAuthResultWithOrgsZ = AdoAuthResultZ.extend({
-  scmOrgs: z15.array(z15.string())
+  scmOrgs: z12.array(z12.string())
 });
-var profileZ = z15.object({
-  displayName: z15.string(),
-  publicAlias: z15.string().min(1),
-  emailAddress: z15.string(),
-  coreRevision: z15.number(),
-  timeStamp: z15.string(),
-  id: z15.string(),
-  revision: z15.number()
+var profileZ = z12.object({
+  displayName: z12.string(),
+  publicAlias: z12.string().min(1),
+  emailAddress: z12.string(),
+  coreRevision: z12.number(),
+  timeStamp: z12.string(),
+  id: z12.string(),
+  revision: z12.number()
 });
-var accountsZ = z15.object({
-  count: z15.number(),
-  value: z15.array(
-    z15.object({
-      accountId: z15.string(),
-      accountUri: z15.string(),
-      accountName: z15.string()
+var accountsZ = z12.object({
+  count: z12.number(),
+  value: z12.array(
+    z12.object({
+      accountId: z12.string(),
+      accountUri: z12.string(),
+      accountName: z12.string()
     })
   )
 });
@@ -6552,7 +4930,7 @@ async function getAdoConnectData({
         oauthToken: adoTokenInfo.accessToken
       });
       return {
-        org: z16.string().parse(org),
+        org: z13.string().parse(org),
         origin: DEFUALT_ADO_ORIGIN
       };
     }
@@ -6638,7 +5016,7 @@ async function getAdoClientParams(params) {
       return {
         tokenType: "PAT" /* PAT */,
         accessToken: adoTokenInfo.accessToken,
-        patTokenOrg: z16.string().parse(tokenOrg).toLowerCase(),
+        patTokenOrg: z13.string().parse(tokenOrg).toLowerCase(),
         origin,
         orgName: org.toLowerCase()
       };
@@ -7778,40 +6156,40 @@ import querystring2 from "querystring";
 import * as bitbucketPkgNode from "bitbucket";
 import bitbucketPkg from "bitbucket";
 import Debug2 from "debug";
-import { z as z19 } from "zod";
+import { z as z16 } from "zod";
 
 // src/features/analysis/scm/bitbucket/validation.ts
-import { z as z18 } from "zod";
-var BitbucketAuthResultZ = z18.object({
-  access_token: z18.string(),
-  token_type: z18.string(),
-  refresh_token: z18.string()
+import { z as z15 } from "zod";
+var BitbucketAuthResultZ = z15.object({
+  access_token: z15.string(),
+  token_type: z15.string(),
+  refresh_token: z15.string()
 });
 
 // src/features/analysis/scm/bitbucket/bitbucket.ts
 var debug3 = Debug2("scm:bitbucket");
 var BITBUCKET_HOSTNAME = "bitbucket.org";
-var TokenExpiredErrorZ = z19.object({
-  status: z19.number(),
-  error: z19.object({
-    type: z19.string(),
-    error: z19.object({
-      message: z19.string()
+var TokenExpiredErrorZ = z16.object({
+  status: z16.number(),
+  error: z16.object({
+    type: z16.string(),
+    error: z16.object({
+      message: z16.string()
     })
   })
 });
 var BITBUCKET_ACCESS_TOKEN_URL = `https://${BITBUCKET_HOSTNAME}/site/oauth2/access_token`;
 var MAX_BITBUCKET_PR_BODY_LENGTH = 32768;
-var BitbucketParseResultZ = z19.object({
-  organization: z19.string(),
-  repoName: z19.string(),
-  hostname: z19.literal(BITBUCKET_HOSTNAME)
+var BitbucketParseResultZ = z16.object({
+  organization: z16.string(),
+  repoName: z16.string(),
+  hostname: z16.literal(BITBUCKET_HOSTNAME)
 });
-var UserWorkspacePermissionsRepositoriesResponseZ = z19.object({
-  values: z19.array(
-    z19.object({
-      repository: z19.object({
-        full_name: z19.string().optional()
+var UserWorkspacePermissionsRepositoriesResponseZ = z16.object({
+  values: z16.array(
+    z16.object({
+      repository: z16.object({
+        full_name: z16.string().optional()
       }).optional()
     })
   ).optional()
@@ -7874,7 +6252,7 @@ function getBitbucketSdk(params) {
       if (!res.data.values) {
         return [];
       }
-      return res.data.values.filter((branch) => !!branch.name).map((branch) => z19.string().parse(branch.name));
+      return res.data.values.filter((branch) => !!branch.name).map((branch) => z16.string().parse(branch.name));
     },
     async getIsUserCollaborator(params2) {
       const { repoUrl } = params2;
@@ -7994,7 +6372,7 @@ function getBitbucketSdk(params) {
       return GetReferenceResultZ.parse({
         sha: tagRes.data.target?.hash,
         type: "TAG" /* TAG */,
-        date: new Date(z19.string().parse(tagRes.data.target?.date))
+        date: new Date(z16.string().parse(tagRes.data.target?.date))
       });
     },
     async getBranchRef(params2) {
@@ -8002,7 +6380,7 @@ function getBitbucketSdk(params) {
       return GetReferenceResultZ.parse({
         sha: getBranchRes.target?.hash,
         type: "BRANCH" /* BRANCH */,
-        date: new Date(z19.string().parse(getBranchRes.target?.date))
+        date: new Date(z16.string().parse(getBranchRes.target?.date))
       });
     },
     async getCommitRef(params2) {
@@ -8010,13 +6388,13 @@ function getBitbucketSdk(params) {
       return GetReferenceResultZ.parse({
         sha: getCommitRes.hash,
         type: "COMMIT" /* COMMIT */,
-        date: new Date(z19.string().parse(getCommitRes.date))
+        date: new Date(z16.string().parse(getCommitRes.date))
       });
     },
     async getDownloadUrl({ url, sha }) {
       this.getReferenceData({ ref: sha, url });
       const repoRes = await this.getRepo({ repoUrl: url });
-      const parsedRepoUrl = z19.string().url().parse(repoRes.links?.html?.href);
+      const parsedRepoUrl = z16.string().url().parse(repoRes.links?.html?.href);
       return `${parsedRepoUrl}/get/${sha}.zip`;
     },
     async getPullRequest(params2) {
@@ -8174,7 +6552,7 @@ async function validateBitbucketParams(params) {
 }
 async function getUsersWorkspacesSlugs(bitbucketClient) {
   const res = await bitbucketClient.workspaces.getWorkspaces({});
-  return res.data.values?.map((v) => z19.string().parse(v.slug));
+  return res.data.values?.map((v) => z16.string().parse(v.slug));
 }
 async function getAllUsersRepositories(bitbucketClient) {
   const userWorkspacesSlugs = await getUsersWorkspacesSlugs(bitbucketClient);
@@ -8202,11 +6580,11 @@ async function getRepositoriesByWorkspace(bitbucketClient, { workspaceSlug }) {
 
 // src/features/analysis/scm/bitbucket/BitbucketSCMLib.ts
 import { setTimeout as setTimeout3 } from "timers/promises";
-import { z as z20 } from "zod";
+import { z as z17 } from "zod";
 var BITBUCKET_API_TOKEN_GIT_USERNAME = "x-bitbucket-api-token-auth";
 function getUserAndPassword(token) {
   const [username, password] = token.split(":");
-  const safePasswordAndUsername = z20.object({ username: z20.string(), password: z20.string() }).parse({ username, password });
+  const safePasswordAndUsername = z17.object({ username: z17.string(), password: z17.string() }).parse({ username, password });
   return {
     username: safePasswordAndUsername.username,
     password: safePasswordAndUsername.password
@@ -8282,7 +6660,7 @@ var BitbucketSCMLib = class extends SCMLib {
         return { username, password, authType };
       }
       case "token": {
-        return { authType, token: z20.string().parse(this.accessToken) };
+        return { authType, token: z17.string().parse(this.accessToken) };
       }
       case "public":
         return { authType };
@@ -8296,7 +6674,7 @@ var BitbucketSCMLib = class extends SCMLib {
           ...params,
           repoUrl: this.url
         });
-        return String(z20.number().parse(pullRequestRes.id));
+        return String(z17.number().parse(pullRequestRes.id));
       } catch (e) {
         console.warn(
           `error creating pull request for BB. Try number ${String(i + 1).replace(/\n|\r/g, "")}`,
@@ -8381,7 +6759,7 @@ var BitbucketSCMLib = class extends SCMLib {
   async getUsername() {
     this._validateAccessToken();
     const res = await this.bitbucketSdk.getUser();
-    return z20.string().parse(res["username"]);
+    return z17.string().parse(res["username"]);
   }
   async getSubmitRequestStatus(_scmSubmitRequestId) {
     this._validateAccessTokenAndUrl();
@@ -8407,7 +6785,7 @@ var BitbucketSCMLib = class extends SCMLib {
   async getRepoDefaultBranch() {
     this._validateUrl();
     const repoRes = await this.bitbucketSdk.getRepo({ repoUrl: this.url });
-    return z20.string().parse(repoRes.mainbranch?.name);
+    return z17.string().parse(repoRes.mainbranch?.name);
   }
   getSubmitRequestUrl(submitRequestId) {
     this._validateUrl();
@@ -8575,7 +6953,7 @@ init_env();
 
 // src/features/analysis/scm/github/GithubSCMLib.ts
 import pLimit3 from "p-limit";
-import { z as z21 } from "zod";
+import { z as z18 } from "zod";
 init_client_generates();
 
 // src/features/analysis/scm/github/github.ts
@@ -9743,7 +8121,7 @@ var GithubSCMLib = class extends SCMLib {
       owner,
       repo
     });
-    return z21.string().parse(prRes.data);
+    return z18.string().parse(prRes.data);
   }
   async getRepoList(_scmOrg) {
     this._validateAccessToken();
@@ -10370,11 +8748,11 @@ import {
 init_env();
 
 // src/features/analysis/scm/gitlab/types.ts
-import { z as z22 } from "zod";
-var GitlabAuthResultZ = z22.object({
-  access_token: z22.string(),
-  token_type: z22.string(),
-  refresh_token: z22.string()
+import { z as z19 } from "zod";
+var GitlabAuthResultZ = z19.object({
+  access_token: z19.string(),
+  token_type: z19.string(),
+  refresh_token: z19.string()
 });
 
 // src/features/analysis/scm/gitlab/gitlab.ts
@@ -10589,8 +8967,8 @@ async function getGitlabProjectLanguages({
 }) {
   try {
     const api2 = getGitBeaker({ url, gitlabAuthToken: accessToken });
-    const languages3 = await api2.Projects.showLanguages(projectId);
-    return Object.keys(languages3);
+    const languages = await api2.Projects.showLanguages(projectId);
+    return Object.keys(languages);
   } catch (e) {
     debug4(
       "[getGitlabProjectLanguages] Failed for project %d: %s",
@@ -11592,7 +9970,7 @@ var GitlabSCMLib = class extends SCMLib {
 };
 
 // src/features/analysis/scm/scmFactory.ts
-import { z as z23 } from "zod";
+import { z as z20 } from "zod";
 
 // src/features/analysis/scm/StubSCMLib.ts
 var StubSCMLib = class extends SCMLib {
@@ -11745,7 +10123,7 @@ async function createScmLib({ url, accessToken, scmType, scmOrg }, {
     if (e instanceof InvalidRepoUrlError && url) {
       throw new RepoNoTokenAccessError(
         "no access to repo",
-        scmLibScmTypeToScmType[z23.nativeEnum(ScmLibScmType).parse(scmType)]
+        scmLibScmTypeToScmType[z20.nativeEnum(ScmLibScmType).parse(scmType)]
       );
     }
     console.error(`error validating scm: ${scmType} `, e);
@@ -12352,7 +10730,7 @@ import path6 from "path";
 import chalk from "chalk";
 import Debug4 from "debug";
 import * as dotenv from "dotenv";
-import { z as z24 } from "zod";
+import { z as z21 } from "zod";
 var debug5 = Debug4("mobbdev:constants");
 var runtimeConfigPath = path6.join(
   getModuleRootDir(),
@@ -12399,17 +10777,17 @@ var scannerToVulnerabilityReportVendorEnum = {
   [SCANNERS.Datadog]: "datadog" /* Datadog */,
   [SCANNERS.BlackDuck]: "blackDuck" /* BlackDuck */
 };
-var SupportedScannersZ = z24.enum([SCANNERS.Checkmarx, SCANNERS.Snyk]);
-var envVariablesSchema = z24.object({
+var SupportedScannersZ = z21.enum([SCANNERS.Checkmarx, SCANNERS.Snyk]);
+var envVariablesSchema = z21.object({
   // These have safe defaults for production - the VS Code extension passes explicit URLs
-  WEB_APP_URL: z24.string().optional().default(DEFAULT_WEB_APP_URL),
-  API_URL: z24.string().optional().default(DEFAULT_API_URL),
+  WEB_APP_URL: z21.string().optional().default(DEFAULT_WEB_APP_URL),
+  API_URL: z21.string().optional().default(DEFAULT_API_URL),
   // These are only needed for local development with Hasura
-  HASURA_ACCESS_KEY: z24.string().optional().default(""),
-  LOCAL_GRAPHQL_ENDPOINT: z24.string().optional().default(""),
+  HASURA_ACCESS_KEY: z21.string().optional().default(""),
+  LOCAL_GRAPHQL_ENDPOINT: z21.string().optional().default(""),
   // Proxy settings
-  HTTP_PROXY: z24.string().optional().default(""),
-  HTTPS_PROXY: z24.string().optional().default("")
+  HTTP_PROXY: z21.string().optional().default(""),
+  HTTPS_PROXY: z21.string().optional().default("")
 });
 var envVariables = envVariablesSchema.parse(process.env);
 debug5("config %o", envVariables);
@@ -12667,7 +11045,7 @@ import { createSpinner as createSpinner4 } from "nanospinner";
 import fetch4 from "node-fetch";
 import open3 from "open";
 import tmp2 from "tmp";
-import { z as z30 } from "zod";
+import { z as z27 } from "zod";
 
 // src/commands/AuthManager.ts
 import crypto from "crypto";
@@ -12944,62 +11322,62 @@ init_client_generates();
 
 // src/features/analysis/graphql/types.ts
 init_client_generates();
-import { z as z25 } from "zod";
-var VulnerabilityReportIssueCodeNodeZ = z25.object({
-  vulnerabilityReportIssueId: z25.string(),
-  path: z25.string(),
-  startLine: z25.number(),
-  vulnerabilityReportIssue: z25.object({
-    fixId: z25.string(),
-    category: z25.nativeEnum(Vulnerability_Report_Issue_Category_Enum),
-    safeIssueType: z25.string(),
-    vulnerabilityReportIssueTags: z25.array(
-      z25.object({
-        tag: z25.nativeEnum(Vulnerability_Report_Issue_Tag_Enum)
+import { z as z22 } from "zod";
+var VulnerabilityReportIssueCodeNodeZ = z22.object({
+  vulnerabilityReportIssueId: z22.string(),
+  path: z22.string(),
+  startLine: z22.number(),
+  vulnerabilityReportIssue: z22.object({
+    fixId: z22.string(),
+    category: z22.nativeEnum(Vulnerability_Report_Issue_Category_Enum),
+    safeIssueType: z22.string(),
+    vulnerabilityReportIssueTags: z22.array(
+      z22.object({
+        tag: z22.nativeEnum(Vulnerability_Report_Issue_Tag_Enum)
       })
     )
   })
 });
-var VulnerabilityReportIssueNoFixCodeNodeZ = z25.object({
-  vulnerabilityReportIssues: z25.array(
-    z25.object({
-      id: z25.string(),
-      fixId: z25.string().nullable(),
-      category: z25.nativeEnum(Vulnerability_Report_Issue_Category_Enum),
-      safeIssueType: z25.string(),
-      fpId: z25.string().uuid().nullable(),
-      codeNodes: z25.array(
-        z25.object({
-          path: z25.string(),
-          startLine: z25.number()
+var VulnerabilityReportIssueNoFixCodeNodeZ = z22.object({
+  vulnerabilityReportIssues: z22.array(
+    z22.object({
+      id: z22.string(),
+      fixId: z22.string().nullable(),
+      category: z22.nativeEnum(Vulnerability_Report_Issue_Category_Enum),
+      safeIssueType: z22.string(),
+      fpId: z22.string().uuid().nullable(),
+      codeNodes: z22.array(
+        z22.object({
+          path: z22.string(),
+          startLine: z22.number()
         })
       ),
-      vulnerabilityReportIssueTags: z25.array(
-        z25.object({
-          tag: z25.nativeEnum(Vulnerability_Report_Issue_Tag_Enum)
+      vulnerabilityReportIssueTags: z22.array(
+        z22.object({
+          tag: z22.nativeEnum(Vulnerability_Report_Issue_Tag_Enum)
         })
       )
     })
   )
 });
-var GetVulByNodesMetadataZ = z25.object({
-  vulnerabilityReportIssueCodeNodes: z25.array(VulnerabilityReportIssueCodeNodeZ),
-  nonFixablePrVuls: z25.object({
-    aggregate: z25.object({
-      count: z25.number()
+var GetVulByNodesMetadataZ = z22.object({
+  vulnerabilityReportIssueCodeNodes: z22.array(VulnerabilityReportIssueCodeNodeZ),
+  nonFixablePrVuls: z22.object({
+    aggregate: z22.object({
+      count: z22.number()
     })
   }),
-  fixablePrVuls: z25.object({
-    aggregate: z25.object({
-      count: z25.number()
+  fixablePrVuls: z22.object({
+    aggregate: z22.object({
+      count: z22.number()
     })
   }),
-  totalScanVulnerabilities: z25.object({
-    aggregate: z25.object({
-      count: z25.number()
+  totalScanVulnerabilities: z22.object({
+    aggregate: z22.object({
+      count: z22.number()
     })
   }),
-  irrelevantVulnerabilityReportIssue: z25.array(
+  irrelevantVulnerabilityReportIssue: z22.array(
     VulnerabilityReportIssueNoFixCodeNodeZ
   )
 });
@@ -13521,7 +11899,7 @@ import * as os2 from "os";
 import path7 from "path";
 import chalk4 from "chalk";
 import { withFile } from "tmp-promise";
-import z26 from "zod";
+import z23 from "zod";
 
 // src/commands/handleMobbLogin.ts
 import chalk3 from "chalk";
@@ -14061,8 +12439,8 @@ var defaultLogger2 = {
     }
   }
 };
-var PromptItemZ = z26.object({
-  type: z26.enum([
+var PromptItemZ = z23.object({
+  type: z23.enum([
     "USER_PROMPT",
     "AI_RESPONSE",
     "TOOL_EXECUTION",
@@ -14070,32 +12448,32 @@ var PromptItemZ = z26.object({
     "MCP_TOOL_CALL"
     // MCP (Model Context Protocol) tool invocation
   ]),
-  attachedFiles: z26.array(
-    z26.object({
-      relativePath: z26.string(),
-      startLine: z26.number().optional()
+  attachedFiles: z23.array(
+    z23.object({
+      relativePath: z23.string(),
+      startLine: z23.number().optional()
     })
   ).optional(),
-  tokens: z26.object({
-    inputCount: z26.number(),
-    outputCount: z26.number()
+  tokens: z23.object({
+    inputCount: z23.number(),
+    outputCount: z23.number()
   }).optional(),
-  text: z26.string().optional(),
-  date: z26.date().optional(),
-  tool: z26.object({
-    name: z26.string(),
-    parameters: z26.string(),
-    result: z26.string(),
-    rawArguments: z26.string().optional(),
-    accepted: z26.boolean().optional(),
+  text: z23.string().optional(),
+  date: z23.date().optional(),
+  tool: z23.object({
+    name: z23.string(),
+    parameters: z23.string(),
+    result: z23.string(),
+    rawArguments: z23.string().optional(),
+    accepted: z23.boolean().optional(),
     // MCP-specific fields (only populated for MCP_TOOL_CALL type)
-    mcpServer: z26.string().optional(),
+    mcpServer: z23.string().optional(),
     // MCP server name (e.g., "datadog", "mobb-mcp")
-    mcpToolName: z26.string().optional()
+    mcpToolName: z23.string().optional()
     // MCP tool name without prefix (e.g., "scan_and_fix_vulnerabilities")
   }).optional()
 });
-var PromptItemArrayZ = z26.array(PromptItemZ);
+var PromptItemArrayZ = z23.array(PromptItemZ);
 var NULL_REPO_STATE = {
   repositoryUrl: null,
   branch: null,
@@ -15033,7 +13411,7 @@ import Debug15 from "debug";
 // src/features/analysis/add_fix_comments_for_pr/utils/utils.ts
 import Debug14 from "debug";
 import parseDiff from "parse-diff";
-import { z as z28 } from "zod";
+import { z as z25 } from "zod";
 
 // src/features/analysis/utils/by_key.ts
 function keyBy(array, keyBy2) {
@@ -15122,7 +13500,7 @@ var scannerToFriendlyString = {
 
 // src/features/analysis/add_fix_comments_for_pr/utils/buildCommentBody.ts
 import Debug13 from "debug";
-import { z as z27 } from "zod";
+import { z as z24 } from "zod";
 init_client_generates();
 var debug14 = Debug13("mobbdev:handle-finished-analysis");
 var getCommitFixButton = (commitUrl) => `<a href="${commitUrl}"><img src=${COMMIT_FIX_SVG}></a>`;
@@ -15168,10 +13546,10 @@ function buildFixCommentBody({
   });
   const issueType = getIssueTypeFriendlyString(fix.safeIssueType);
   const title = `# ${MobbIconMarkdown} ${issueType} fix is ready`;
-  const validFixParseRes = z27.object({
+  const validFixParseRes = z24.object({
     patchAndQuestions: PatchAndQuestionsZ,
-    safeIssueLanguage: z27.nativeEnum(IssueLanguage_Enum),
-    severityText: z27.nativeEnum(Vulnerability_Severity_Enum),
+    safeIssueLanguage: z24.nativeEnum(IssueLanguage_Enum),
+    severityText: z24.nativeEnum(Vulnerability_Severity_Enum),
     safeIssueType: SafeIssueTypeStringZ
   }).safeParse(fix);
   if (!validFixParseRes.success) {
@@ -15406,7 +13784,7 @@ async function getRelevantVulenrabilitiesFromDiff(params) {
     });
     const lineAddedRanges = calculateRanges(fileNumbers);
     const fileFilter = {
-      path: z28.string().parse(file.to),
+      path: z25.string().parse(file.to),
       ranges: lineAddedRanges.map(([startLine, endLine]) => ({
         endLine,
         startLine
@@ -15718,15 +14096,15 @@ import { globby } from "globby";
 import { isBinary as isBinary2 } from "istextorbinary";
 import { simpleGit as simpleGit3 } from "simple-git";
 import { parseStringPromise } from "xml2js";
-import { z as z29 } from "zod";
+import { z as z26 } from "zod";
 var debug19 = Debug18("mobbdev:pack");
-var FPR_SOURCE_CODE_FILE_MAPPING_SCHEMA = z29.object({
-  properties: z29.object({
-    entry: z29.array(
-      z29.object({
-        _: z29.string(),
-        $: z29.object({
-          key: z29.string()
+var FPR_SOURCE_CODE_FILE_MAPPING_SCHEMA = z26.object({
+  properties: z26.object({
+    entry: z26.array(
+      z26.object({
+        _: z26.string(),
+        $: z26.object({
+          key: z26.string()
         })
       })
     )
@@ -16510,7 +14888,7 @@ async function _scan(params, { skipPrompts = false } = {}) {
     spinner: mobbSpinner,
     submitVulnerabilityReportVariables: {
       fixReportId: reportUploadInfo.fixReportId,
-      repoUrl: z30.string().parse(repo),
+      repoUrl: z27.string().parse(repo),
       reference,
       projectId,
       vulnerabilityReportFileName: shouldScan ? void 0 : REPORT_DEFAULT_FILE_NAME,
@@ -16850,9 +15228,9 @@ async function waitForAnaysisAndReviewPr({
   gqlClient,
   polling
 }) {
-  const params = z30.object({
-    repo: z30.string().url(),
-    githubActionToken: z30.string()
+  const params = z27.object({
+    repo: z27.string().url(),
+    githubActionToken: z27.string()
   }).parse({ repo, githubActionToken });
   const scm = await createScmLib(
     {
@@ -16870,7 +15248,7 @@ async function waitForAnaysisAndReviewPr({
       analysisId: analysisId2,
       gqlClient,
       scm,
-      scanner: z30.nativeEnum(SCANNERS).parse(scanner)
+      scanner: z27.nativeEnum(SCANNERS).parse(scanner)
     });
   };
   if (polling) {
@@ -17186,7 +15564,7 @@ async function scanSkill(options) {
 // src/args/validation.ts
 import chalk9 from "chalk";
 import path12 from "path";
-import { z as z31 } from "zod";
+import { z as z28 } from "zod";
 function throwRepoUrlErrorMessage({
   error,
   repoUrl,
@@ -17203,11 +15581,11 @@ Example:
   )}`;
   throw new CliError(formattedErrorMessage);
 }
-var UrlZ = z31.string({
+var UrlZ = z28.string({
   invalid_type_error: `is not a valid ${Object.values(ScmType).join("/ ")} URL`
 });
 function validateOrganizationId(organizationId) {
-  const orgIdValidation = z31.string().uuid().nullish().safeParse(organizationId);
+  const orgIdValidation = z28.string().uuid().nullish().safeParse(organizationId);
   if (!orgIdValidation.success) {
     throw new CliError(`organizationId: ${organizationId} is not a valid UUID`);
   }
@@ -19354,7 +17732,7 @@ function createLogger(config2) {
 
 // src/features/claude_code/hook_logger.ts
 var DD_RUM_TOKEN = true ? "pubf59c0182545bfb4c299175119f1abf9b" : "";
-var CLI_VERSION = true ? "1.4.35" : "unknown";
+var CLI_VERSION = true ? "1.4.36" : "unknown";
 var NAMESPACE = "mobbdev-claude-code-hook-logs";
 var claudeCodeVersion;
 function buildDdTags() {
@@ -20884,150 +19262,151 @@ init_client_generates();
 init_configs();
 
 // src/mcp/types.ts
-import { z as z32 } from "zod";
+import { z as z29 } from "zod";
 init_client_generates();
-var ScanAndFixVulnerabilitiesToolSchema = z32.object({
-  path: z32.string()
+var ScanAndFixVulnerabilitiesToolSchema = z29.object({
+  path: z29.string()
 });
-var VulnerabilityReportIssueTagSchema = z32.object({
-  vulnerability_report_issue_tag_value: z32.nativeEnum(
+var VulnerabilityReportIssueTagSchema = z29.object({
+  vulnerability_report_issue_tag_value: z29.nativeEnum(
     Vulnerability_Report_Issue_Tag_Enum
   )
 });
-var VulnerabilityReportIssueSchema = z32.object({
-  category: z32.any().optional().nullable(),
+var VulnerabilityReportIssueSchema = z29.object({
+  category: z29.any().optional().nullable(),
   parsedIssueType: SafeIssueTypeStringZ.nullable().optional(),
-  parsedSeverity: z32.nativeEnum(Vulnerability_Severity_Enum).nullable().optional(),
-  vulnerabilityReportIssueTags: z32.array(VulnerabilityReportIssueTagSchema)
+  parsedSeverity: z29.nativeEnum(Vulnerability_Severity_Enum).nullable().optional(),
+  vulnerabilityReportIssueTags: z29.array(VulnerabilityReportIssueTagSchema)
 });
-var SharedStateSchema = z32.object({
-  __typename: z32.literal("fix_shared_state").optional(),
-  id: z32.any(),
+var SharedStateSchema = z29.object({
+  __typename: z29.literal("fix_shared_state").optional(),
+  id: z29.any(),
   // GraphQL uses `any` type for UUID
-  downloadedBy: z32.array(z32.any().nullable()).optional().nullable()
+  downloadedBy: z29.array(z29.any().nullable()).optional().nullable()
 });
-var UnstructuredFixExtraContextSchema = z32.object({
-  __typename: z32.literal("UnstructuredFixExtraContext").optional(),
-  key: z32.string(),
-  value: z32.any()
+var UnstructuredFixExtraContextSchema = z29.object({
+  __typename: z29.literal("UnstructuredFixExtraContext").optional(),
+  key: z29.string(),
+  value: z29.any()
   // GraphQL JSON type
 });
-var FixExtraContextResponseSchema = z32.object({
-  __typename: z32.literal("FixExtraContextResponse").optional(),
-  extraContext: z32.array(UnstructuredFixExtraContextSchema),
-  fixDescription: z32.string()
+var FixExtraContextResponseSchema = z29.object({
+  __typename: z29.literal("FixExtraContextResponse").optional(),
+  extraContext: z29.array(UnstructuredFixExtraContextSchema),
+  fixDescription: z29.string()
 });
-var FixQuestionSchema = z32.object({
-  __typename: z32.literal("FixQuestion").optional(),
-  key: z32.string(),
-  name: z32.string(),
-  defaultValue: z32.string(),
-  value: z32.string().nullable().optional(),
-  inputType: z32.nativeEnum(FixQuestionInputType),
-  options: z32.array(z32.string()),
-  index: z32.number(),
-  extraContext: z32.array(UnstructuredFixExtraContextSchema),
-  // E-2015 PR5: analyzer-served question copy. default('') -> FE falls back when
-  // a query omits it, while the output type stays a required string.
-  content: z32.string().default(""),
-  description: z32.string().default(""),
-  guidance: z32.string().default("")
+var FixQuestionSchema = z29.object({
+  __typename: z29.literal("FixQuestion").optional(),
+  key: z29.string(),
+  name: z29.string(),
+  defaultValue: z29.string(),
+  value: z29.string().nullable().optional(),
+  inputType: z29.nativeEnum(FixQuestionInputType),
+  options: z29.array(z29.string()),
+  index: z29.number(),
+  extraContext: z29.array(UnstructuredFixExtraContextSchema),
+  // E-2015: analyzer-served question text. default('') so a query that omits it
+  // still parses, while the output type stays a required string. The analyzer is
+  // the sole source; consumers use the served value directly (no fallback).
+  content: z29.string().default(""),
+  description: z29.string().default(""),
+  guidance: z29.string().default("")
 });
-var FixDataSchema = z32.object({
-  __typename: z32.literal("FixData"),
-  patch: z32.string(),
-  patchOriginalEncodingBase64: z32.string(),
-  questions: z32.array(FixQuestionSchema),
+var FixDataSchema = z29.object({
+  __typename: z29.literal("FixData"),
+  patch: z29.string(),
+  patchOriginalEncodingBase64: z29.string(),
+  questions: z29.array(FixQuestionSchema),
   extraContext: FixExtraContextResponseSchema
 });
-var GetFixNoFixErrorSchema = z32.object({
-  __typename: z32.literal("GetFixNoFixError")
+var GetFixNoFixErrorSchema = z29.object({
+  __typename: z29.literal("GetFixNoFixError")
 });
-var PatchAndQuestionsSchema = z32.union([FixDataSchema, GetFixNoFixErrorSchema]);
-var McpFixSchema = z32.object({
-  __typename: z32.literal("fix").optional(),
-  id: z32.any(),
+var PatchAndQuestionsSchema = z29.union([FixDataSchema, GetFixNoFixErrorSchema]);
+var McpFixSchema = z29.object({
+  __typename: z29.literal("fix").optional(),
+  id: z29.any(),
   // GraphQL uses `any` type for UUID
-  confidence: z32.number(),
-  safeIssueType: z32.string().nullable(),
-  safeIssueLanguage: z32.string().nullable().optional(),
-  severityText: z32.string().nullable(),
-  gitBlameLogin: z32.string().nullable().optional(),
+  confidence: z29.number(),
+  safeIssueType: z29.string().nullable(),
+  safeIssueLanguage: z29.string().nullable().optional(),
+  severityText: z29.string().nullable(),
+  gitBlameLogin: z29.string().nullable().optional(),
   // Optional in GraphQL
-  severityValue: z32.number().nullable(),
-  vulnerabilityReportIssues: z32.array(VulnerabilityReportIssueSchema),
+  severityValue: z29.number().nullable(),
+  vulnerabilityReportIssues: z29.array(VulnerabilityReportIssueSchema),
   sharedState: SharedStateSchema.nullable().optional(),
   // Optional in GraphQL
   patchAndQuestions: PatchAndQuestionsSchema,
   // Additional field added by the client
-  fixUrl: z32.string().optional()
+  fixUrl: z29.string().optional()
 });
-var FixAggregateSchema = z32.object({
-  __typename: z32.literal("fix_aggregate").optional(),
-  aggregate: z32.object({
-    __typename: z32.literal("fix_aggregate_fields").optional(),
-    count: z32.number()
+var FixAggregateSchema = z29.object({
+  __typename: z29.literal("fix_aggregate").optional(),
+  aggregate: z29.object({
+    __typename: z29.literal("fix_aggregate_fields").optional(),
+    count: z29.number()
   }).nullable()
 });
-var VulnerabilityReportIssueAggregateSchema = z32.object({
-  __typename: z32.literal("vulnerability_report_issue_aggregate").optional(),
-  aggregate: z32.object({
-    __typename: z32.literal("vulnerability_report_issue_aggregate_fields").optional(),
-    count: z32.number()
+var VulnerabilityReportIssueAggregateSchema = z29.object({
+  __typename: z29.literal("vulnerability_report_issue_aggregate").optional(),
+  aggregate: z29.object({
+    __typename: z29.literal("vulnerability_report_issue_aggregate_fields").optional(),
+    count: z29.number()
   }).nullable()
 });
-var RepoSchema = z32.object({
-  __typename: z32.literal("repo").optional(),
-  originalUrl: z32.string()
+var RepoSchema = z29.object({
+  __typename: z29.literal("repo").optional(),
+  originalUrl: z29.string()
 });
-var ProjectSchema = z32.object({
-  id: z32.any(),
+var ProjectSchema = z29.object({
+  id: z29.any(),
   // GraphQL uses `any` type for UUID
-  organizationId: z32.any()
+  organizationId: z29.any()
   // GraphQL uses `any` type for UUID
 });
-var VulnerabilityReportSchema = z32.object({
-  scanDate: z32.any().nullable(),
+var VulnerabilityReportSchema = z29.object({
+  scanDate: z29.any().nullable(),
   // GraphQL uses `any` type for timestamp
-  vendor: z32.string(),
+  vendor: z29.string(),
   // GraphQL generates as string, not enum
-  projectId: z32.any().optional(),
+  projectId: z29.any().optional(),
   // GraphQL uses `any` type for UUID
   project: ProjectSchema,
   totalVulnerabilityReportIssuesCount: VulnerabilityReportIssueAggregateSchema,
   notFixableVulnerabilityReportIssuesCount: VulnerabilityReportIssueAggregateSchema
 });
-var FixReportSummarySchema = z32.object({
-  __typename: z32.literal("fixReport").optional(),
-  id: z32.any(),
+var FixReportSummarySchema = z29.object({
+  __typename: z29.literal("fixReport").optional(),
+  id: z29.any(),
   // GraphQL uses `any` type for UUID
-  createdOn: z32.any(),
+  createdOn: z29.any(),
   // GraphQL uses `any` type for timestamp
   repo: RepoSchema.nullable(),
-  issueTypes: z32.any().nullable(),
+  issueTypes: z29.any().nullable(),
   // GraphQL uses `any` type for JSON
   CRITICAL: FixAggregateSchema,
   HIGH: FixAggregateSchema,
   MEDIUM: FixAggregateSchema,
   LOW: FixAggregateSchema,
-  fixes: z32.array(McpFixSchema),
-  userFixes: z32.array(McpFixSchema).optional(),
+  fixes: z29.array(McpFixSchema),
+  userFixes: z29.array(McpFixSchema).optional(),
   // Present in some responses but can be omitted
   filteredFixesCount: FixAggregateSchema,
   totalFixesCount: FixAggregateSchema,
   vulnerabilityReport: VulnerabilityReportSchema
 });
-var ExpiredReportSchema = z32.object({
-  __typename: z32.literal("fixReport").optional(),
-  id: z32.any(),
+var ExpiredReportSchema = z29.object({
+  __typename: z29.literal("fixReport").optional(),
+  id: z29.any(),
   // GraphQL uses `any` type for UUID
-  expirationOn: z32.any().nullable()
+  expirationOn: z29.any().nullable()
   // GraphQL uses `any` type for timestamp
 });
-var GetLatestReportByRepoUrlResponseSchema = z32.object({
-  __typename: z32.literal("query_root").optional(),
-  fixReport: z32.array(FixReportSummarySchema),
-  expiredReport: z32.array(ExpiredReportSchema)
+var GetLatestReportByRepoUrlResponseSchema = z29.object({
+  __typename: z29.literal("query_root").optional(),
+  fixReport: z29.array(FixReportSummarySchema),
+  expiredReport: z29.array(ExpiredReportSchema)
 });
 
 // src/mcp/services/InteractiveFixFilter.ts
@@ -22837,10 +21216,10 @@ var McpServer = class {
 };
 
 // src/mcp/prompts/CheckForNewVulnerabilitiesPrompt.ts
-import { z as z34 } from "zod";
+import { z as z31 } from "zod";
 
 // src/mcp/prompts/base/BasePrompt.ts
-import { z as z33 } from "zod";
+import { z as z30 } from "zod";
 var BasePrompt = class {
   getDefinition() {
     return {
@@ -22869,7 +21248,7 @@ var BasePrompt = class {
       const argsToValidate = args === void 0 ? {} : args;
       return this.argumentsValidationSchema.parse(argsToValidate);
     } catch (error) {
-      if (error instanceof z33.ZodError) {
+      if (error instanceof z30.ZodError) {
         const errorDetails = error.errors.map((e) => {
           const fieldPath = e.path.length > 0 ? e.path.join(".") : "root";
           const message = e.message === "Required" ? `Missing required argument '${fieldPath}'` : `Invalid value for '${fieldPath}': ${e.message}`;
@@ -22898,8 +21277,8 @@ var BasePrompt = class {
 };
 
 // src/mcp/prompts/CheckForNewVulnerabilitiesPrompt.ts
-var CheckForNewVulnerabilitiesArgsSchema = z34.object({
-  path: z34.string().optional()
+var CheckForNewVulnerabilitiesArgsSchema = z31.object({
+  path: z31.string().optional()
 });
 var CheckForNewVulnerabilitiesPrompt = class extends BasePrompt {
   constructor() {
@@ -23144,9 +21523,9 @@ Call the \`check_for_new_available_fixes\` tool now${args?.path ? ` for ${args.p
 };
 
 // src/mcp/prompts/FullSecurityAuditPrompt.ts
-import { z as z35 } from "zod";
-var FullSecurityAuditArgsSchema = z35.object({
-  path: z35.string().optional()
+import { z as z32 } from "zod";
+var FullSecurityAuditArgsSchema = z32.object({
+  path: z32.string().optional()
 });
 var FullSecurityAuditPrompt = class extends BasePrompt {
   constructor() {
@@ -23597,9 +21976,9 @@ Begin the audit now${args?.path ? ` for ${args.path}` : ""}.
 };
 
 // src/mcp/prompts/ReviewAndFixCriticalPrompt.ts
-import { z as z36 } from "zod";
-var ReviewAndFixCriticalArgsSchema = z36.object({
-  path: z36.string().optional()
+import { z as z33 } from "zod";
+var ReviewAndFixCriticalArgsSchema = z33.object({
+  path: z33.string().optional()
 });
 var ReviewAndFixCriticalPrompt = class extends BasePrompt {
   constructor() {
@@ -23903,9 +22282,9 @@ Start by scanning${args?.path ? ` ${args.path}` : " the repository"} and priorit
 };
 
 // src/mcp/prompts/ScanRecentChangesPrompt.ts
-import { z as z37 } from "zod";
-var ScanRecentChangesArgsSchema = z37.object({
-  path: z37.string().optional()
+import { z as z34 } from "zod";
+var ScanRecentChangesArgsSchema = z34.object({
+  path: z34.string().optional()
 });
 var ScanRecentChangesPrompt = class extends BasePrompt {
   constructor() {
@@ -24116,9 +22495,9 @@ You now have the guidance needed to perform a fast, targeted security scan of re
 };
 
 // src/mcp/prompts/ScanRepositoryPrompt.ts
-import { z as z38 } from "zod";
-var ScanRepositoryArgsSchema = z38.object({
-  path: z38.string().optional()
+import { z as z35 } from "zod";
+var ScanRepositoryArgsSchema = z35.object({
+  path: z35.string().optional()
 });
 var ScanRepositoryPrompt = class extends BasePrompt {
   constructor() {
@@ -24516,7 +22895,7 @@ import * as os15 from "os";
 import * as path29 from "path";
 
 // src/mcp/tools/checkForNewAvailableFixes/CheckForNewAvailableFixesTool.ts
-import { z as z40 } from "zod";
+import { z as z37 } from "zod";
 
 // src/mcp/services/PathValidation.ts
 import fs21 from "fs";
@@ -24592,7 +22971,7 @@ async function validatePath(inputPath) {
 }
 
 // src/mcp/tools/base/BaseTool.ts
-import { z as z39 } from "zod";
+import { z as z36 } from "zod";
 var BaseTool = class {
   getDefinition() {
     return {
@@ -24619,7 +22998,7 @@ var BaseTool = class {
     try {
       return this.inputValidationSchema.parse(args);
     } catch (error) {
-      if (error instanceof z39.ZodError) {
+      if (error instanceof z36.ZodError) {
         const errorDetails = error.errors.map((e) => {
           const fieldPath = e.path.length > 0 ? e.path.join(".") : "root";
           const message = e.message === "Required" ? `Missing required parameter '${fieldPath}'` : `Invalid value for '${fieldPath}': ${e.message}`;
@@ -24658,39 +23037,12 @@ function friendlyType(s) {
 var noFixesReturnedForParameters = `No fixes returned for the given offset and limit parameters.
 `;
 var resolveQuestionText = ({
-  fix,
   question
 }) => {
-  if (question.content || question.description) {
-    return {
-      content: question.content || question.name,
-      description: question.description ?? ""
-    };
-  }
-  const language = fix.safeIssueLanguage ?? void 0;
-  const issueType = fix.safeIssueType ?? void 0;
-  if (!language || !issueType) {
-    return { content: question.name, description: "" };
-  }
-  const item = storedQuestionData_default[language]?.[issueType]?.[question.name];
-  if (!item) {
-    return { content: question.name, description: "" };
-  }
-  const args = question.extraContext.reduce(
-    (acc, ctx) => {
-      acc[ctx.key] = ctx.value;
-      return acc;
-    },
-    {}
-  );
-  try {
-    return {
-      content: item.content(args) || question.name,
-      description: item.description(args) || ""
-    };
-  } catch {
-    return { content: question.name, description: "" };
-  }
+  return {
+    content: question.content || question.name,
+    description: question.description ?? ""
+  };
 };
 var formatQuestionInputContract = (question) => {
   switch (question.inputType) {
@@ -24707,7 +23059,7 @@ var renderInteractiveFix = (fix, index) => {
   const { questions, extraContext } = fix.patchAndQuestions;
   const vulnerabilityType = friendlyType(fix.safeIssueType ?? "Unknown");
   const questionsBlock = questions.slice().sort((a, b) => a.index - b.index).map((q, qIdx) => {
-    const { content, description } = resolveQuestionText({ fix, question: q });
+    const { content, description } = resolveQuestionText({ question: q });
     const desc = description ? `
   *Why it matters:* ${description}` : "";
     const defaultLine = q.defaultValue ? `
@@ -28224,8 +26576,8 @@ Example payload:
       },
       required: ["path"]
     });
-    __publicField(this, "inputValidationSchema", z40.object({
-      path: z40.string().describe(
+    __publicField(this, "inputValidationSchema", z37.object({
+      path: z37.string().describe(
         "Full local path to the cloned git repository to check for new available fixes"
       )
     }));
@@ -28255,7 +26607,7 @@ Example payload:
 
 // src/mcp/tools/fetchAvailableFixes/FetchAvailableFixesTool.ts
 init_GitService();
-import { z as z41 } from "zod";
+import { z as z38 } from "zod";
 
 // src/mcp/tools/fetchAvailableFixes/FetchAvailableFixesService.ts
 init_configs();
@@ -28401,16 +26753,16 @@ Call this tool instead of ${MCP_TOOL_SCAN_AND_FIX_VULNERABILITIES} when you only
       },
       required: ["path"]
     });
-    __publicField(this, "inputValidationSchema", z41.object({
-      path: z41.string().describe(
+    __publicField(this, "inputValidationSchema", z38.object({
+      path: z38.string().describe(
         "Full local path to the cloned git repository to check for available fixes"
       ),
-      offset: z41.number().optional().describe("Optional offset for pagination"),
-      limit: z41.number().optional().describe("Optional maximum number of fixes to return"),
-      fileFilter: z41.array(z41.string()).optional().describe(
+      offset: z38.number().optional().describe("Optional offset for pagination"),
+      limit: z38.number().optional().describe("Optional maximum number of fixes to return"),
+      fileFilter: z38.array(z38.string()).optional().describe(
         "Optional list of file paths relative to the path parameter to filter fixes by. INCOMPATIBLE with fetchFixesFromAnyFile"
       ),
-      fetchFixesFromAnyFile: z41.boolean().optional().describe(
+      fetchFixesFromAnyFile: z38.boolean().optional().describe(
         "Optional boolean to fetch fixes for all files. INCOMPATIBLE with fileFilter"
       )
     }));
@@ -28476,7 +26828,7 @@ Call this tool instead of ${MCP_TOOL_SCAN_AND_FIX_VULNERABILITIES} when you only
 };
 
 // src/mcp/tools/mcpChecker/mcpCheckerTool.ts
-import z42 from "zod";
+import z39 from "zod";
 
 // src/mcp/tools/mcpChecker/mcpCheckerService.ts
 var _McpCheckerService = class _McpCheckerService {
@@ -28537,7 +26889,7 @@ var McpCheckerTool = class extends BaseTool {
     __publicField(this, "displayName", "MCP Checker");
     // A detailed description to guide the LLM on when and how to invoke this tool.
     __publicField(this, "description", "Check the MCP servers running on this IDE against organization policies.");
-    __publicField(this, "inputValidationSchema", z42.object({}));
+    __publicField(this, "inputValidationSchema", z39.object({}));
     __publicField(this, "inputSchema", {
       type: "object",
       properties: {},
@@ -28563,7 +26915,7 @@ var McpCheckerTool = class extends BaseTool {
 };
 
 // src/mcp/tools/scanAndFixVulnerabilities/ScanAndFixVulnerabilitiesTool.ts
-import z43 from "zod";
+import z40 from "zod";
 init_configs();
 
 // src/mcp/tools/scanAndFixVulnerabilities/ScanAndFixVulnerabilitiesService.ts
@@ -28943,26 +27295,26 @@ Example payload (Mode B \u2014 abstain from every interactive fix, no rescan):
   "interactiveAnswers": []
 }`);
     __publicField(this, "hasAuthentication", true);
-    __publicField(this, "inputValidationSchema", z43.object({
-      path: z43.string().describe(
+    __publicField(this, "inputValidationSchema", z40.object({
+      path: z40.string().describe(
         "Full local path to repository to scan and fix vulnerabilities"
       ),
-      offset: z43.number().optional().describe("Optional offset for pagination"),
-      limit: z43.number().optional().describe("Optional maximum number of results to return"),
-      maxFiles: z43.number().optional().describe(
+      offset: z40.number().optional().describe("Optional offset for pagination"),
+      limit: z40.number().optional().describe("Optional maximum number of results to return"),
+      maxFiles: z40.number().optional().describe(
         `Optional maximum number of files to scan (default: ${MCP_DEFAULT_MAX_FILES_TO_SCAN}). Increase for comprehensive scans of larger codebases or decrease for faster focused scans.`
       ),
-      rescan: z43.boolean().optional().describe("Optional whether to rescan the repository"),
-      scanRecentlyChangedFiles: z43.boolean().optional().describe(
+      rescan: z40.boolean().optional().describe("Optional whether to rescan the repository"),
+      scanRecentlyChangedFiles: z40.boolean().optional().describe(
         "Optional whether to automatically scan recently changed files when no changed files are found in git status. If false, the tool will prompt the user instead."
       ),
-      interactiveAnswers: z43.array(
-        z43.object({
-          fixId: z43.string().min(1).describe('Fix id from a previous "Interactive fix" prompt block.'),
-          answers: z43.array(
-            z43.object({
-              key: z43.string().min(1).describe("FixQuestion key."),
-              value: z43.string().describe(
+      interactiveAnswers: z40.array(
+        z40.object({
+          fixId: z40.string().min(1).describe('Fix id from a previous "Interactive fix" prompt block.'),
+          answers: z40.array(
+            z40.object({
+              key: z40.string().min(1).describe("FixQuestion key."),
+              value: z40.string().describe(
                 "For SELECT questions MUST be one of the listed options; for TEXT/NUMBER, a free-form value."
               )
             })
@@ -29325,7 +27677,7 @@ async function addScmTokenHandler(args) {
 }
 
 // src/features/codeium_intellij/data_collector.ts
-import { z as z44 } from "zod";
+import { z as z41 } from "zod";
 
 // src/utils/read-stdin.ts
 import { setTimeout as setTimeout4 } from "timers";
@@ -29442,12 +27794,12 @@ function promisifyClient(client) {
     }
   });
 }
-async function getGrpcClient(port, csrf3) {
+async function getGrpcClient(port, csrf) {
   const client = promisifyClient(
     new PROTO.exa.language_server_pb.LanguageServerService(
       `localhost:${port}`,
       grpc.credentials.createInsecure(),
-      { interceptors: [createCsrfInterceptor(csrf3)] }
+      { interceptors: [createCsrfInterceptor(csrf)] }
     )
   );
   try {
@@ -29527,8 +27879,8 @@ function findRunningCodeiumLanguageServers() {
 }
 
 // src/features/codeium_intellij/data_collector.ts
-var HookDataSchema = z44.object({
-  trajectory_id: z44.string()
+var HookDataSchema = z41.object({
+  trajectory_id: z41.string()
 });
 async function processAndUploadHookData() {
   const tracePayload = await getTraceDataForHook();