@eodash/eodash 5.6.0 → 5.7.0

package/dist/client/{handling-C285F_Mq.js → handling-BrcDDlgS.js}

@@ -1,15 +1,261 @@
 import log from 'loglevel';
-import { s as separateEndpointLinks, c as createTiffLayerDefinition, p as pollProcessStatus, e as extractAsyncResults, u as updateJobsStatus, a as creatAsyncProcessLayerDefinitions, b as getBboxProperty, f as generateTimePairs, h as updateJsonformSchemaTarget, i as extractGeometries, j as applyProcessLayersToMap, g as getDrawToolsProperty } from './async-CT3KEV52.js';
-import { d as axios, b as extractLayerConfig, I as compareIndicator, F as indicator, y as extractCollectionUrls, H as currentCompareUrl, G as currentUrl, z as generateLinksFromItems, o as getDatetimeProperty, J as comparePoi, B as datetime, Z as compareChartData, _ as chartData, O as compareChartSpec, N as chartSpec, C as poi, v as getLayers } from './helpers-CZFH0EVN.js';
+import { s as separateEndpointLinks, c as createTiffLayerDefinition, p as pollProcessStatus, e as extractAsyncResults, u as updateJobsStatus, a as creatAsyncProcessLayerDefinitions, b as getBboxProperty, f as generateTimePairs, h as extractGeometries, i as applyProcessLayersToMap, g as getDrawToolsProperties } from './async-DSKj6g1f.js';
+import { d as axios, b as extractLayerConfig, H as compareIndicator, E as indicator, x as extractCollectionUrls, G as currentCompareUrl, F as currentUrl, y as generateLinksFromItems, o as getDatetimeProperty, I as comparePoi, A as datetime, Z as compareChartData, _ as chartData, N as compareChartSpec, M as chartSpec, B as poi, Y as getCompareLayers, v as getLayers } from './helpers-DjZVl_WF.js';
 import mustache from 'mustache';
-import { T as isFirstLoad, H as useSTAcStore, X as readParquetItems, Y as useGetSubCodeId } from './asWebComponent-DDt7V3Bl.js';
+import { S as isFirstLoad, H as useSTAcStore, W as readParquetItems, X as useGetSubCodeId } from './asWebComponent-BHWpMuE3.js';
 import { toAbsolute } from 'stac-js/src/http.js';
 
+/**
+ * Returns form value keys that match the multiQuery configuration.
+ * @param {Record<string, any> | undefined} jsonformValue
+ * @param {Record<string, any>} jsonformSchema
+ * @returns {string[]}
+ */
+function getMultiQueryMatches(jsonformValue, jsonformSchema) {
+  const multiQuery = jsonformSchema?.options?.multiQuery;
+  return Object.keys(jsonformValue ?? {}).filter((key) => {
+    return Array.isArray(multiQuery)
+      ? multiQuery.includes(key)
+      : multiQuery === key;
+  });
+}
+
+/**
+ * Extracts iterable scalar values for a multiQuery field.
+ * Wraps single values in an array; returns empty array for undefined.
+ * @param {string} match - The multiQuery field name
+ * @param {Record<string, any>} jsonformValue
+ * @returns {any[]}
+ */
+function getScalarMultiQueryValues(match, jsonformValue) {
+  const value = jsonformValue?.[match];
+  if (Array.isArray(value)) {
+    return value;
+  }
+  return value === undefined ? [] : [value];
+}
+
+/**
+ * Extracts iterable values for a POST multiQuery field.
+ * For GeoJSON fields, uses rawJsonformValue to get original Feature objects
+ * (before extractGeometries stringifies them). For scalar fields, delegates
+ * to getScalarMultiQueryValues.
+ * @param {string} match - The multiQuery field name
+ * @param {Record<string, any>} jsonformValue - Form values after geometry extraction
+ * @param {Record<string, any> | undefined} rawJsonformValue - Form values before geometry extraction
+ * @param {Record<string, any>} jsonformSchema
+ * @returns {any[]}
+ */
+function getPostMultiQueryValues(
+  match,
+  jsonformValue,
+  rawJsonformValue,
+  jsonformSchema,
+) {
+  if (jsonformSchema?.properties?.[match]?.type === "geojson") {
+    return getGeoJsonMultiQueryValues(rawJsonformValue?.[match]);
+  }
+  return getScalarMultiQueryValues(match, jsonformValue);
+}
+
+/**
+ * Extracts individual GeoJSON Feature objects from a value that may be
+ * a FeatureCollection, a single Feature, or an array of Features.
+ * Filters for valid Features with geometry and deduplicates.
+ * @param {any} value
+ * @returns {Record<string, any>[]}
+ */
+function getGeoJsonMultiQueryValues(value) {
+  if (value?.type === "FeatureCollection") {
+    return dedupeMultiQueryValues(
+      (value.features ?? []).filter(
+        (/** @type {any} */ feature) =>
+          feature?.type === "Feature" && feature.geometry,
+      ),
+    );
+  }
+  if (value?.type === "Feature") {
+    return [value];
+  }
+  if (Array.isArray(value)) {
+    return dedupeMultiQueryValues(
+      value.filter(
+        (/** @type {any} */ feature) =>
+          feature?.type === "Feature" && feature.geometry,
+      ),
+    );
+  }
+  return [];
+}
+
+/**
+ * Removes duplicate values using JSON serialization as the identity key.
+ * @param {any[]} values
+ * @returns {any[]}
+ */
+function dedupeMultiQueryValues(values) {
+  const seen = new Set();
+  const deduped = [];
+  for (const value of values ?? []) {
+    const key =
+      value && typeof value === "object"
+        ? JSON.stringify(value)
+        : String(value);
+    if (seen.has(key)) {
+      continue;
+    }
+    seen.add(key);
+    deduped.push(value);
+  }
+  return deduped;
+}
+
+/**
+ * Builds the Mustache rendering context for one multiQuery iteration.
+ * Spreads the full form value, overrides the matched field with the current
+ * iteration value, and adds a 1-based `multiQueryIndex`.
+ * @param {Record<string, any>} jsonformValue
+ * @param {string} match - The multiQuery field name being iterated
+ * @param {any} value - The current iteration value
+ * @param {number} index - Zero-based iteration index
+ * @returns {Record<string, any>}
+ */
+function createMultiQueryContext(jsonformValue, match, value, index) {
+  return {
+    ...(jsonformValue ?? {}),
+    [match]: value,
+    multiQueryIndex: index + 1,
+  };
+}
+
+/**
+ * Flattens an array of POST responses into a single values array.
+ * Each response that is itself an array is spread; scalars are wrapped.
+ * @param {any[]} values
+ * @returns {any[]}
+ */
+function aggregateInlineResponses(values) {
+  return values.flatMap((value) => (Array.isArray(value) ? value : [value]));
+}
+
+/**
+ * Renders a JSON body template string with the given context.
+ * Primary path: parses the template as JSON, then recursively renders each
+ * node (preserving object-valued placeholders as raw JSON).
+ * Fallback: treats the template as a Mustache string, renders, then parses.
+ * @param {string} bodyTemplate - JSON template string (may contain Mustache placeholders)
+ * @param {Record<string, any>} context - Values to substitute into the template
+ * @returns {any} Parsed JSON body ready for POST
+ */
+function renderJsonBodyTemplate(bodyTemplate, context) {
+  try {
+    const parsedTemplate = JSON.parse(bodyTemplate);
+    return renderTemplateNode(parsedTemplate, context);
+  } catch {
+    try {
+      return JSON.parse(
+        mustache.render(bodyTemplate, {
+          ...(context ?? {}),
+        }),
+      );
+    } catch (e) {
+      throw new Error(
+        `[eodash] Failed to render POST body template: ${e instanceof Error ? e.message : String(e)}`,
+      );
+    }
+  }
+}
+
+/**
+ * Recursively renders a parsed JSON template node with context values.
+ * - Arrays and objects are traversed recursively.
+ * - Exact placeholders (where the entire string value is `"{{path}}"` or
+ *   `"{{{path}}}"`) are resolved to their original typed value (object, array,
+ *   number, etc.) instead of being stringified. This is critical for embedding
+ *   GeoJSON geometry objects in POST bodies.
+ * - Partial placeholders and mixed strings use standard Mustache interpolation.
+ * @param {any} templateNode
+ * @param {Record<string, any>} context
+ * @returns {any}
+ */
+function renderTemplateNode(templateNode, context) {
+  if (Array.isArray(templateNode)) {
+    return templateNode.map((value) => renderTemplateNode(value, context));
+  }
+  if (templateNode && typeof templateNode === "object") {
+    return Object.fromEntries(
+      Object.entries(templateNode).map(([key, value]) => [
+        mustache.render(key, context),
+        renderTemplateNode(value, context),
+      ]),
+    );
+  }
+  if (typeof templateNode !== "string") {
+    return templateNode;
+  }
+
+  // Detect exact placeholder: entire value is "{{path}}" or "{{{path}}}".
+  // Matches both double-brace {{...}} and triple-brace {{{...}}} syntax.
+  // When matched, the resolved value is returned as its original type (e.g. an
+  // object), rather than being coerced to a string by Mustache.
+  const exactPlaceholder = templateNode.match(
+    /^\{\{\{?\s*([^{}]+?)\s*\}?\}\}$/,
+  );
+  if (exactPlaceholder) {
+    const resolvedValue = resolveTemplatePath(context, exactPlaceholder[1]);
+    if (resolvedValue !== undefined) {
+      return cloneTemplateValue(resolvedValue);
+    }
+  }
+
+  return mustache.render(templateNode, context);
+}
+
+/**
+ * Resolves a dot/bracket-notation path against a context object.
+ * Supports paths like `"feature.geometry"` or `"list[0].name"`.
+ * @param {Record<string, any>} context
+ * @param {string} path
+ * @returns {any}
+ */
+function resolveTemplatePath(context, path) {
+  const segments = path
+    .replace(/\[(\d+)\]/g, ".$1")
+    .split(".")
+    .map((segment) => segment.trim())
+    .filter(Boolean);
+
+  let currentValue = context;
+  for (const segment of segments) {
+    if (currentValue === null || currentValue === undefined) {
+      return undefined;
+    }
+    currentValue = currentValue[segment];
+  }
+  return currentValue;
+}
+
+/**
+ * Deep-clones objects via JSON round-trip to prevent template rendering
+ * from mutating the original context values. This also strips non-JSON-
+ * serializable properties (e.g. OL Feature methods from drawtools),
+ * producing clean plain objects. Primitives pass through.
+ * @param {any} value
+ * @returns {any}
+ */
+function cloneTemplateValue(value) {
+  if (value && typeof value === "object") {
+    return JSON.parse(JSON.stringify(value));
+  }
+  return value;
+}
+
 ////// --- CHARTS --- //////
 /**
  * @param {object} options
  * @param {import("stac-ts").StacLink[] | undefined} options.links
  * @param {Record<string,any> | undefined} options.jsonformValue
+ * @param {Record<string,any> | undefined} [options.rawJsonformValue]
  * @param {string} options.specUrl
  * @param {(input:import("^/EodashProcess/types").CustomEnpointInput)=>Promise<Record<string,any>[] | undefined | null>} [options.customEndpointsHandler]
  * @param {import("vue").Ref<boolean>} options.isPolling
@@ -22,6 +268,7 @@ import { toAbsolute } from 'stac-js/src/http.js';
 async function processCharts({
   links,
   jsonformValue,
+  rawJsonformValue,
   specUrl,
   customEndpointsHandler,
   jsonformSchema,
@@ -51,6 +298,7 @@ async function processCharts({
     (await customEndpointsHandler({
       jsonformSchema,
       jsonformValue,
+      rawJsonformValue,
       links: endpointLinks,
       selectedStac,
       isPolling,
@@ -112,6 +360,7 @@ async function processCharts({
           await injectVegaInlineData(spec, {
             url: link.href,
             jsonformValue: jsonformValue,
+            rawJsonformValue,
             link: link,
             flatstyleUrl: /** @type string */ (link["eox:flatstyle"]),
             jsonformSchema,
@@ -138,46 +387,39 @@ async function processCharts({
  * @param {object} injectables
  * @param {string} injectables.url
  * @param {Record<string,any>} [injectables.jsonformValue]
+ * @param {Record<string,any>} [injectables.rawJsonformValue]
  * @param {import("stac-ts").StacLink} injectables.link
  * @param {url} [injectables.flatstyleUrl]
  * @param {import("json-schema").JSONSchema7} [injectables.jsonformSchema]
  */
 async function injectVegaInlineData(
   spec,
-  { url, jsonformValue, link, flatstyleUrl, jsonformSchema },
+  { url, jsonformValue, rawJsonformValue, link, flatstyleUrl, jsonformSchema },
 ) {
   if (!spec.data) {
     return;
   }
+  // @ts-expect-error JSONSchema7 is structurally compatible with Record<string, any>
+  const multiQueryMatches = getMultiQueryMatches(jsonformValue, jsonformSchema);
   if (link.method == "GET") {
-    // we see if any of the multiQuery values match an array in the jsonformValue
-    // and if so, we can do multiple requests and merge all data together.
-    //@ts-expect-error type jsonform Schema
-    const multiQuery = jsonformSchema?.options?.multiQuery;
-    const matches = Object.keys(jsonformValue ?? {}).filter((key) => {
-      return Array.isArray(multiQuery)
-        ? multiQuery.includes(key)
-        : multiQuery === key;
-    });
-    if (matches.length > 0 && jsonformValue) {
+    if (multiQueryMatches.length > 0 && jsonformValue) {
       const dataValues = [];
-      for (const match of matches) {
-        if (Array.isArray(jsonformValue[match])) {
-          for (const value of jsonformValue[match]) {
-            const dataUrl = await renderDataUrl(
-              url,
-              { ...jsonformValue, [match]: value },
-              flatstyleUrl,
-            );
-            dataValues.push(await axios.get(dataUrl).then((resp) => resp.data));
-          }
-        } else {
-          const dataUrl = await renderDataUrl(url, jsonformValue, flatstyleUrl);
+      for (const match of multiQueryMatches) {
+        const queryValues = getScalarMultiQueryValues(match, jsonformValue);
+        if (!queryValues.length) {
+          continue;
+        }
+        for (const value of queryValues) {
+          const dataUrl = await renderDataUrl(
+            url,
+            { ...jsonformValue, [match]: value },
+            flatstyleUrl,
+          );
           dataValues.push(await axios.get(dataUrl).then((resp) => resp.data));
         }
       }
       /** @type {import("vega-lite/build/src/data").InlineData} */
-      (spec.data).values = dataValues.flat();
+      (spec.data).values = aggregateInlineResponses(dataValues);
       return spec;
     }
     // if no array matches, we can just do a single request
@@ -201,11 +443,49 @@ async function injectVegaInlineData(
       .then((resp) => {
         return resp.data;
       });
-    const body = JSON.parse(
-      mustache.render(bodyTemplate, {
-        ...(jsonformValue ?? {}),
-      }),
-    );
+    if (
+      // @ts-expect-error jsonform options extension not in JSONSchema7
+      jsonformSchema?.options?.multiQuery &&
+      multiQueryMatches.length === 0
+    ) {
+      /** @type {import("vega-lite/build/src/data").InlineData} */
+      (spec.data).values = [];
+      return spec;
+    }
+    if (multiQueryMatches.length > 0 && jsonformValue) {
+      const responses = [];
+      for (const match of multiQueryMatches) {
+        const queryValues = getPostMultiQueryValues(
+          match,
+          jsonformValue,
+          rawJsonformValue,
+          /** @type {Record<string, any>} */ (jsonformSchema),
+        );
+        if (!queryValues.length) {
+          continue;
+        }
+        // Sequential POSTs (not parallel) to avoid rate-limiting on endpoints
+        // like TiTiler-PgSTAC. For small selection counts this is fine; if
+        // parallelism is needed later, switch to Promise.all.
+        for (const [index, value] of queryValues.entries()) {
+          const requestContext = createMultiQueryContext(
+            jsonformValue,
+            match,
+            value,
+            index,
+          );
+          const body = renderJsonBodyTemplate(bodyTemplate, requestContext);
+          responses.push(await axios.post(url, body).then((resp) => resp.data));
+        }
+      }
+      /** @type {import("vega-lite/build/src/data").InlineData} */
+      (spec.data).values = aggregateInlineResponses(responses);
+      return spec;
+    }
+
+    const body = renderJsonBodyTemplate(bodyTemplate, {
+      ...(jsonformValue ?? {}),
+    });
     /** @type {import("vega-lite/build/src/data").InlineData} */
     (spec.data).values = await axios.post(url, body).then((resp) => {
       return resp.data;
@@ -214,6 +494,8 @@ async function injectVegaInlineData(
   return spec;
 }
 
+// MultiQuery helpers and template rendering are in ./template-helpers.js
+
 /**
  * @param {import("vega-lite").TopLevelSpec} spec
  * @param {object} injectables
@@ -651,7 +933,7 @@ async function handleSentinelHubProcess({
     [jsonformValue["start_date"], jsonformValue["end_date"]],
     jsonformValue["distribution"]
   );
-  return await Promise.all(
+  const results = await Promise.all(
     timePairs.map(([to, from]) => {
       return fetchSentinelHubData({
         url: endpoint,
@@ -660,14 +942,16 @@ async function handleSentinelHubProcess({
         from,
         to,
         exampleLink: evalScriptLink
-      }).catch(
-        (err) => console.error(
+      }).catch((err) => {
+        console.error(
           "[eodash] Error while fetching data from sentinel hub endpoint:",
           err
-        )
-      );
+        );
+        return [];
+      });
     })
-  ).then((data) => data.flat().map((data2) => data2.outputs.data));
+  ).then((data) => data.filter((result) => result.length > 0)).then((data) => data.flat().map((data2) => data2.outputs.data));
+  return results;
 }
 async function sentinelHubAuth(clientId, clientSecret) {
   if (!clientId || !clientSecret) {
@@ -853,7 +1137,7 @@ async function handleVedaEndpoint({
     vedaLink,
   );
   // TODO: convert jsonform bbox type to geojson in the schema to avoid the conversion here
-  return await Promise.all(
+  const results = await Promise.all(
     configs.map(({ endpoint, datetime }) => {
       const url = new URL(vedaEndpoint);
       const key = vedaLink.endpoint === "veda_stac" ? "ids" : "url";
@@ -872,14 +1156,17 @@ async function handleVedaEndpoint({
           fetchedSats.date = datetime;
           return fetchedSats;
         })
-        .catch((resp) =>
+        .catch((resp) => {
           console.error(
             "[eodash] Error while fetching data from veda endpoint:",
             resp,
-          ),
-        );
+          );
+          return null;
+        });
     }),
   );
+  // Filter out the nulls (failed requests) before returning
+  return results.filter((result) => result !== null);
 }
 
 /**
@@ -1005,37 +1292,58 @@ function createCustomChartEndpointsHandler(callbacks) {
  * @async
  * @param {Object} params
  * @param {import("vue").Ref<import("stac-ts").StacCollection | null>} params.selectedStac
- * @param {import("vue").Ref<import("@eox/jsonform").EOxJSONForm | null>} params.jsonformEl
  * @param {import("vue").Ref<Record<string,any> | null>} params.jsonformSchema
  * @param {import("vue").Ref<any[]>} params.processResults
  * @param {import("vue").Ref<boolean>} params.isProcessed
  * @param {import("vue").Ref<boolean>} params.loading
  * @param {import("vue").Ref<boolean>} params.isPolling
+ * @param {import("@eox/map").EOxMap | null} params.mapElement
  * @param {boolean} params.enableCompare
  */
 async function initProcess({
   selectedStac,
-  jsonformEl,
   jsonformSchema,
   isProcessed,
   processResults,
   loading,
   isPolling,
   enableCompare,
+  mapElement,
 }) {
   const isPoiAlive = enableCompare ? !!comparePoi.value : !!poi.value;
   let updatedJsonform = null;
   if (selectedStac.value?.["eodash:jsonform"]) {
-    updatedJsonform = await axios
+    updatedJsonform = await fetch(
       //@ts-expect-error eodash extention
-      .get(selectedStac.value["eodash:jsonform"])
-      .then((resp) => resp.data);
+      selectedStac.value["eodash:jsonform"],
+    ).then((resp) => resp.json());
   }
 
   if (!updatedJsonform && isPoiAlive) {
     jsonformSchema.value = null;
     return;
   }
+
+  if (!updatedJsonform) {
+    resetProcess({
+      loading,
+      isProcessed,
+      jsonformSchema,
+      isPolling,
+      processResults,
+      enableCompare,
+    });
+    return;
+  }
+
+  const newJsonForm = await updateJsonformIdentifier({
+    jsonformSchema: updatedJsonform,
+    newLayers: enableCompare ? getCompareLayers() : getLayers(),
+    enableCompare,
+    mapElement,
+  });
+  if (!newJsonForm) return;
+
   resetProcess({
     loading,
     isProcessed,
@@ -1044,89 +1352,109 @@ async function initProcess({
     processResults,
     enableCompare,
   });
+  jsonformSchema.value = newJsonForm;
+}
 
-  await jsonformEl.value?.editor.destroy();
-  if (updatedJsonform) {
-    // make sure correct target layer id is used in jsonform
-    let newJsonForm = null;
-    newJsonForm = await updateJsonformIdentifier({
-      jsonformSchema: updatedJsonform,
-      newLayers: getLayers(),
-    });
-    if (enableCompare) {
-      newJsonForm = updateJsonformSchemaTarget(newJsonForm);
+/**
+ * Recursively search grouped layer tree for a layer whose id starts with the given prefix
+ *
+ * @param {Record<string, any>[]} layers
+ * @param {string} prefix
+ * @returns {string | null}
+ */
+function findLayerIdByPrefix(layers, prefix) {
+  for (const layer of layers) {
+    if (layer.type === "Group" && Array.isArray(layer.layers)) {
+      const found = findLayerIdByPrefix(layer.layers, prefix);
+      if (found) return found;
+    } else if (layer.properties?.id?.startsWith(prefix)) {
+      return layer.properties.id;
     }
-    // trigger jsonform update in next tick
-    jsonformSchema.value = null;
-    await new Promise((resolve) => setTimeout(resolve, 0));
-    jsonformSchema.value = newJsonForm;
   }
+  return null;
+}
+
+/**
+ * Wait until a layer's features are loaded for the drawtools to attach correctly
+ * Resolves immediately if already loaded.
+ *
+ * @param {import("@eox/map").AnyLayerWithSource | null | undefined} layer
+ * @returns {Promise<void>}
+ */
+function waitForLayerRender(layer) {
+  return new Promise((resolve, reject) => {
+    if (!layer || layer.get("type") !== "Vector" || !("getSource" in layer))
+      return resolve();
+    const source = /** @type {import("ol/source/Vector").default} */ (
+      layer.getSource()
+    );
+    if (!source || source.getFeatures().length > 0) return resolve();
+    source.once("featuresloadend", () => resolve());
+    source.once("featuresloaderror", () =>
+      reject(new Error(`Layer ${layer.get("id")} failed to load features`)),
+    );
+  });
 }
 
 /**
- * Update the jsonform schema to have the correct layer id from the map
+ * Update the jsonform schema to have the correct layer id from the map.
+ * Returns null if any required layerId cannot be resolved (layer not yet in map).
+ * Callers should treat null as "retry when layers:updated fires".
  *
  * @export
- * @async
  * @param {Object} params
- * @param {Record<string,any> | null} params.jsonformSchema params.jsonformSchema
- * @param {Record<string, any>[] | undefined} params.newLayers params.newLayers
- * @returns {Promise<Record<string,any> | null | undefined>} updated jsonform schema
+ * @param {Record<string,any> | null} params.jsonformSchema
+ * @param {Record<string, any>[] | undefined} params.newLayers
+ * @param {boolean} params.enableCompare
+ * @param {import("@eox/map").EOxMap | null | undefined} params.mapElement
+ * @returns {Promise<Record<string,any> | null>} updated schema, or null if a layerId could not be resolved
  */
-async function updateJsonformIdentifier({ jsonformSchema, newLayers }) {
-  const form = jsonformSchema;
-  if (!form) {
-    return;
-  }
-  const drawToolsProperty = getDrawToolsProperty(form);
-  if (
-    drawToolsProperty &&
-    newLayers &&
-    form?.properties[drawToolsProperty]?.options?.drawtools?.layerId
-  ) {
-    // get partial or full id and try to match with correct eoxmap layer
-    // check if newLayers is an array or an object with layers property
-    let layers = newLayers;
-    // @ts-expect-error TODO payload coming from time update sometimes is not an object with layers property
-    if (newLayers.layers && Array.isArray(newLayers.layers)) {
-      // @ts-expect-error TODO payload coming from time update sometimes is not an object with layers property
-      layers = newLayers.layers;
+async function updateJsonformIdentifier({
+  jsonformSchema,
+  newLayers,
+  enableCompare,
+  mapElement,
+}) {
+  if (!jsonformSchema || !newLayers) return null;
+
+  const form = JSON.parse(JSON.stringify(jsonformSchema));
+  const drawToolsProperties = getDrawToolsProperties(form);
+  /** @type {Promise<void>[]} */
+  const renderPromises = [];
+
+  for (const drawToolsProperty of drawToolsProperties) {
+    if (!drawToolsProperty) continue;
+
+    const drawtoolsOptions =
+      form?.properties[drawToolsProperty]?.options?.drawtools;
+    if (!drawtoolsOptions) continue;
+
+    if (drawtoolsOptions.for && enableCompare) {
+      drawtoolsOptions.for = "eox-map#compare";
     }
 
-    const layerId =
-      form.properties[drawToolsProperty].options.drawtools.layerId.split(
-        ";:;",
-      )[0];
-    let matchedLayerId = null;
-    // layers are not flat can be grouped, we need to recursively search
-    const traverseLayers = (
-      /** @type {Record<string, any>[] | undefined} */ layersArray,
-    ) => {
-      if (!layersArray) {
-        return;
-      }
-      for (const layer of layersArray) {
-        if (layer.type === "Group" && Array.isArray(layer.layers)) {
-          traverseLayers(layer.layers);
-        } else {
-          if (layer.properties?.id?.startsWith(layerId)) {
-            matchedLayerId = layer.properties.id;
-            break;
-          }
+    if (drawtoolsOptions.layerId) {
+      let layer = mapElement?.getLayerById(drawtoolsOptions.layerId);
+      if (!layer) {
+        const prefix = drawtoolsOptions.layerId.split(";:;")[0];
+        const resolvedId = findLayerIdByPrefix(newLayers, prefix);
+        if (!resolvedId) {
+          console.warn(
+            `Could not find matching layer for processing form with id: ${prefix}`,
+          );
+          return null;
         }
+        drawtoolsOptions.layerId = resolvedId;
+        layer = mapElement?.getLayerById(resolvedId);
       }
-    };
-    traverseLayers(layers);
-    if (matchedLayerId) {
-      form.properties.feature.options.drawtools.layerId = matchedLayerId;
-      return form;
-    } else {
-      console.warn(
-        `Could not find matching layer for processing form with id: ${layerId}`,
-      );
-      return null;
+      renderPromises.push(waitForLayerRender(layer));
     }
   }
+
+  await Promise.all(renderPromises).catch((err) => {
+    console.warn("[eodash] layer load failed before jsonform attach:", err);
+  });
+
   return form;
 }
 
@@ -1165,6 +1493,15 @@ async function handleProcesses({
     );
 
     const bboxProperty = getBboxProperty(jsonformSchema.value);
+    // Preserve raw form value before extractGeometries mutates it.
+    // Needed so POST multiQuery can iterate original GeoJSON Feature objects.
+    // Uses JSON round-trip instead of structuredClone to handle OL Feature
+    // objects from drawtools (which contain non-cloneable methods).
+    const rawJsonformValue = JSON.parse(
+      JSON.stringify(
+        /** @type {Record<string, any>} */ (jsonformEl.value?.value ?? {}),
+      ),
+    );
     const jsonformValue = /** @type {Record<string,any>} */ (
       jsonformEl.value?.value
     );
@@ -1183,6 +1520,7 @@ async function handleProcesses({
     [tempChartSpec, usedChartData.value] = await processCharts({
       links: serviceLinks,
       jsonformValue: { ...(jsonformValue ?? {}) },
+      rawJsonformValue,
       jsonformSchema: jsonformSchema.value,
       enableCompare,
       selectedStac: selectedStac.value,