@arcgis/ai-components 5.1.0-next.99 → 5.1.0

package/dist/chunks/converterUtils.js

@@ -36,68 +36,74 @@ function x(e) {
     return null;
   for (let r = A(e, 0); r !== -1; r = A(e, r + 1)) {
     let a = 0, c = 0;
-    for (let l = r; l < e.length; l++) {
-      const n = e[l];
-      if (n === "{" ? a++ : n === "}" ? a-- : n === "[" ? c++ : n === "]" && c--, a < 0 || c < 0)
+    for (let n = r; n < e.length; n++) {
+      const l = e[n];
+      if (l === "{" ? a++ : l === "}" ? a-- : l === "[" ? c++ : l === "]" && c--, a < 0 || c < 0)
         break;
-      if (a === 0 && c === 0 && l > r)
-        return e.slice(r, l + 1);
+      if (a === 0 && c === 0 && n > r)
+        return e.slice(r, n + 1);
     }
   }
   return null;
 }
-function H(e) {
+function O(e) {
   if (!e)
     return "";
   let t = e;
   const r = x(e);
   if (r)
     try {
-      const l = JSON.parse(r), f = `
+      const c = JSON.parse(r), l = `
 
 \`\`\`json
-${JSON.stringify(l, null, 2)}
+${JSON.stringify(c, null, 2)}
 \`\`\`
 
 `;
-      t = e.replace(r, f);
+      t = e.replace(r, l);
     } catch {
     }
-  const a = q(t), c = E(a);
-  return T(c);
+  const a = E(t);
+  return q(a);
 }
 function q(e) {
-  return e ? S.parse(e, { async: !1 }) : "";
+  if (!e)
+    return "";
+  const t = M(e);
+  return T(t);
 }
 function E(e) {
+  return e ? S.parse(e, { async: !1 }) : "";
+}
+function M(e) {
   if (!e || typeof DOMParser > "u")
     return e;
   try {
     const t = new DOMParser().parseFromString(e, "text/html");
     return Array.from(t.querySelectorAll("table")).forEach((a, c) => {
-      const l = t.createElement("calcite-table");
-      l.setAttribute("caption", `Table ${c + 1}`), l.setAttribute("striped", "true");
-      const n = a.querySelector("thead");
-      if (n) {
-        const d = Array.from(n.querySelectorAll("tr"));
-        for (const h of d) {
+      const n = t.createElement("calcite-table");
+      n.setAttribute("caption", `Table ${c + 1}`), n.setAttribute("striped", "true");
+      const l = a.querySelector("thead");
+      if (l) {
+        const d = Array.from(l.querySelectorAll("tr"));
+        for (const u of d) {
           const o = t.createElement("calcite-table-row");
           o.setAttribute("slot", "table-header");
-          const u = Array.from(h.querySelectorAll("th, td"));
-          for (const b of u) {
-            const s = (b.textContent ?? "").trim(), i = t.createElement("calcite-table-header");
+          const f = Array.from(u.querySelectorAll("th, td"));
+          for (const h of f) {
+            const s = (h.textContent ?? "").trim(), i = t.createElement("calcite-table-header");
             i.setAttribute("heading", s), o.appendChild(i);
           }
-          l.appendChild(o);
+          n.appendChild(o);
         }
       }
-      const f = a.querySelector("tbody");
-      (f ? Array.from(f.querySelectorAll("tr")) : Array.from(a.querySelectorAll("tr")).filter((d) => !n?.contains(d))).forEach((d, h) => {
-        const o = t.createElement("calcite-table-row"), u = !n && h === 0 && d.querySelectorAll("th").length > 0;
-        u && o.setAttribute("slot", "table-header");
-        const b = Array.from(d.querySelectorAll("th, td"));
-        for (const s of b) {
-          if (u && s.localName === "th") {
+      const b = a.querySelector("tbody");
+      (b ? Array.from(b.querySelectorAll("tr")) : Array.from(a.querySelectorAll("tr")).filter((d) => !l?.contains(d))).forEach((d, u) => {
+        const o = t.createElement("calcite-table-row"), f = !l && u === 0 && d.querySelectorAll("th").length > 0;
+        f && o.setAttribute("slot", "table-header");
+        const h = Array.from(d.querySelectorAll("th, td"));
+        for (const s of h) {
+          if (f && s.localName === "th") {
             const w = (s.textContent ?? "").trim(), y = t.createElement("calcite-table-header");
             y.setAttribute("heading", w), o.appendChild(y);
             return;
@@ -105,13 +111,14 @@ function E(e) {
           const i = t.createElement("calcite-table-cell"), p = s.getAttribute("colspan"), m = s.getAttribute("rowspan");
           p && i.setAttribute("colspan", p), m && i.setAttribute("rowspan", m), i.innerHTML = s.innerHTML, o.appendChild(i);
         }
-        l.appendChild(o);
-      }), a.replaceWith(l);
+        n.appendChild(o);
+      }), a.replaceWith(n);
     }), t.body.innerHTML;
   } catch {
     return e;
   }
 }
 export {
-  H as p
+  q as a,
+  O as p
 };

package/dist/chunks/dataExplorationGraph.js

@@ -0,0 +1,324 @@
+/* COPYRIGHT Esri - https://js.arcgis.com/5.1/LICENSE.txt */
+import { StateGraph as I, START as k, END as v } from "@langchain/langgraph/web";
+import { g as T, O as R, P as C, t as N, Q as V, f, R as D, r as z, S as b, T as P } from "./adapter.js";
+import "@arcgis/core/identity/IdentityManager.js";
+import "@arcgis/core/portal/Portal.js";
+import "@arcgis/toolkit/string";
+import { h as _, e as Q } from "./generateLayerDescriptions.js";
+import { AIMessage as O } from "@langchain/core/messages";
+import { s as n } from "./index.js";
+import "@langchain/openai";
+import "@arcgis/core/config.js";
+import "@arcgis/core/core/reactiveUtils.js";
+import "@arcgis/core/layers/FeatureLayer.js";
+import "@arcgis/core/request.js";
+import "@langchain/core/prompts";
+import { h as $ } from "./toolCallResponse.js";
+import { ToolNode as j } from "@langchain/langgraph/prebuilt";
+import G from "@arcgis/core/smartMapping/statistics/summaryStatistics.js";
+import U from "@arcgis/core/smartMapping/statistics/uniqueValues.js";
+const W = async (t, e) => (await n({ text: "Exiting Data Exploration agent" }, e), t), B = async (t, e) => {
+  await n({ text: "Requesting LLM for layer filter results" }, e);
+  const d = await T("data_explore_filter_prompt");
+  if (!e?.configurable)
+    throw new Error("config.configurable is required for layer filter tools");
+  const { userTimezone: l, userTimezoneOffset: s } = R(), r = {
+    layerFieldInfo: t.layerFieldInfo,
+    userTimezone: l,
+    userTimezoneOffset: s,
+    queryResponse: t.queryResponse,
+    assignedTask: t.agentExecutionContext.assignedTask,
+    userRequest: t.agentExecutionContext.userRequest,
+    priorSteps: t.agentExecutionContext.priorSteps
+  }, o = await _({
+    promptText: d,
+    modelTier: "advanced",
+    config: e,
+    messages: t.dataExplorationMessages,
+    inputVariables: r,
+    tools: C
+  }), i = [...t.dataExplorationMessages, o];
+  if (!((o.tool_calls?.length ?? 0) > 0))
+    return await n({ text: "LLM determined no filter changes needed" }, e), {
+      ...t,
+      dataExplorationMessages: i
+      // Don't overwrite outputMessage if query already set it
+    };
+  const m = i, g = o.content.toString();
+  return await $(o, e), { ...t, dataExplorationMessages: m, outputMessage: g };
+}, H = async (t, e) => {
+  await n({ text: "Requesting LLM for layer query results" }, e);
+  const d = await T("data_explore_query_prompt");
+  if (!e?.configurable)
+    throw new Error("config.configurable is required for layer query tools");
+  const { userTimezone: l, userTimezoneOffset: s } = R(), r = t.agentExecutionContext.sharedState, o = r.lastNavigatedFeatures?.value, i = r.lastResolvedLocation?.value;
+  let c = "none";
+  if (o != null)
+    try {
+      c = JSON.stringify(o);
+    } catch {
+      c = "none";
+    }
+  let m = "none";
+  if (i != null)
+    try {
+      m = JSON.stringify({
+        address: i.address,
+        location: i.location
+      });
+    } catch {
+      m = "none";
+    }
+  const g = {
+    layerFieldInfo: t.layerFieldInfo,
+    userTimezone: l,
+    userTimezoneOffset: s,
+    assignedTask: t.agentExecutionContext.assignedTask,
+    userRequest: t.agentExecutionContext.userRequest,
+    priorSteps: t.agentExecutionContext.priorSteps,
+    lastNavigatedFeatures: c,
+    lastResolvedLocation: m
+  }, y = await _({
+    promptText: d,
+    modelTier: "advanced",
+    config: e,
+    messages: t.dataExplorationMessages,
+    inputVariables: g,
+    tools: V
+  }), h = (y.tool_calls?.length ?? 0) > 0, p = y.content.toString();
+  return await $(y, e), {
+    ...t,
+    dataExplorationMessages: [...t.dataExplorationMessages, y],
+    // Only emit output here when no tools are being called.
+    // For tool-calling flows, downstream summarizer nodes provide the final user-facing message.
+    ...h ? {} : { outputMessage: p },
+    status: "success",
+    summary: p && !h ? N(p) : "Query planning completed."
+  };
+}, J = async (t, e) => {
+  try {
+    await n({ text: "Requesting LLM for summary on query results" }, e);
+    const d = await T("summarize_query_response_prompt"), l = {
+      queryResponse: t.queryResponse,
+      assignedTask: t.agentExecutionContext.assignedTask,
+      userRequest: t.agentExecutionContext.userRequest,
+      priorSteps: t.agentExecutionContext.priorSteps
+    }, s = await Q({
+      promptText: d,
+      modelTier: "fast",
+      config: e,
+      messages: t.dataExplorationMessages,
+      inputVariables: l
+    }), r = typeof s == "string" ? s : s.content, o = new O(r);
+    await n({ text: `Received response from LLM: ${r}` }, e);
+    const i = r;
+    return {
+      ...t,
+      outputMessage: i,
+      status: "success",
+      summary: i ? N(i) : "Summary generated.",
+      dataExplorationMessages: [...t.dataExplorationMessages, o]
+    };
+  } catch (a) {
+    throw await n({ text: "Error during filter LLM request" }, e), new Error(`Error during filter LLM request: ${a instanceof Error ? a.message : String(a)}`);
+  }
+};
+async function K(t, e) {
+  if ((t.queryResponse ?? []).some((s) => {
+    const r = s.details;
+    return typeof r == "object" && r !== null && "error" in r;
+  }))
+    return await n({ text: "Skipping layer filter tool because query response contains an error." }, e), { ...t };
+  const l = await new j(C, { handleToolErrors: !1 }).invoke(
+    {
+      messages: t.dataExplorationMessages
+    },
+    e
+  );
+  return await n(
+    { text: `Finished executing layer filter tool: ${l.messages.map((s) => s.content).join(", ")}` },
+    e
+  ), { ...t };
+}
+const X = 10, Y = ["string", "small-integer", "integer"], Z = async (t, e, { includeSummaryStatistics: a = !0, includeUniqueValues: d = !0 } = {}) => {
+  let l = null, s = null;
+  try {
+    if (e.type !== "geometry" && e.type !== "oid" && e.type !== "global-id") {
+      a && (l = await G({ layer: t, field: e.name }));
+      const r = e.domain?.type === "coded-value" ? e.domain : null;
+      d && (Y.includes(e.type) || r) && (s = (await U({ layer: t, field: e.name })).uniqueValueInfos.sort((o, i) => i.count - o.count).slice(0, X), r && (s = s.map((o) => ({
+        ...o,
+        value: r.getName(o.value) ?? o.value
+      }))));
+    }
+  } catch (r) {
+    console.error(`Error fetching statistics for field ${e.name}:`, r);
+  }
+  return {
+    summaryStatistics: l,
+    uniqueValues: s
+  };
+};
+function ee(t, e) {
+  return ["string", "small-integer", "integer"].includes(t) || e === "coded-value";
+}
+async function te(t, e, a, d = !0) {
+  const l = [], s = [], r = [];
+  for (const o of t) {
+    let i = function(p) {
+      const u = e.get(p)?.layerItem;
+      return u ? [
+        u.name && `Name: ${u.name}`,
+        u.title && `Title: ${u.title}`,
+        u.description && `Description: ${u.description}`
+      ].filter(Boolean).join(" | ") : p;
+    };
+    const { layerId: c, results: m } = o, g = a.map?.allLayers.find((p) => p.id === c), y = e.get(c)?.fieldRegistry;
+    if (!y)
+      continue;
+    let h = l.find((p) => p.layerId === c);
+    h || (h = {
+      layerId: c,
+      layerSummary: i(c),
+      fieldInfos: []
+    }, l.push(h));
+    for (const p of m) {
+      const u = y.get(p.name);
+      if (!u)
+        continue;
+      const x = u.statistics, E = d && !x?.summaryStatistics, w = ee(u.type, u.domain?.type) && !x?.uniqueValues, q = E || w;
+      if (r.push({
+        layerId: c,
+        fieldName: u.name,
+        didFetchStatistics: q
+      }), q) {
+        const A = Z(g, u, {
+          includeSummaryStatistics: E,
+          includeUniqueValues: w
+        }).then((F) => {
+          const S = {
+            summaryStatistics: x?.summaryStatistics ?? null,
+            uniqueValues: x?.uniqueValues ?? null
+          };
+          E && (S.summaryStatistics = F.summaryStatistics), w && (S.uniqueValues = F.uniqueValues), y.set(u.name, { ...u, statistics: S }), u.statistics = S;
+        });
+        s.push(A);
+      }
+      h.fieldInfos.push(u);
+    }
+  }
+  return await Promise.all(s), {
+    layerFieldInfo: l,
+    didFetchStatistics: s.length > 0,
+    fieldStatisticsFetchStatus: r
+  };
+}
+const L = /\b(average|avg|mean|median|max(?:imum)?|min(?:imum)?|sum|total|count|std(?:dev|\s*deviation)|variance|null\s*count|missing\s*values?|range)\b/iu;
+function ae(t, e) {
+  return L.test(t) || L.test(e);
+}
+const se = async (t, e) => {
+  try {
+    await n({ text: "Preparing field information for vector search results" }, e);
+    const a = f(e, "layersAndFieldsRegistry"), { mapView: d } = D(e), { assignedTask: l, userRequest: s } = t.agentExecutionContext, r = ae(l, s), { layerFieldInfo: o, didFetchStatistics: i, fieldStatisticsFetchStatus: c } = await te(
+      t.vectorSearchFieldResults,
+      a,
+      d,
+      r
+    );
+    i ? await n({ text: "Statistics fetched" }, e) : await n({ text: "Statistics skipped" }, e);
+    for (const m of c)
+      await n(
+        {
+          text: `  - ${m.fieldName} - stats ${m.didFetchStatistics ? "fetched" : "skipped"}`
+        },
+        e
+      );
+    return await n({ text: "Field information prepared" }, e), { ...t, layerFieldInfo: o };
+  } catch (a) {
+    throw await n({ text: "Error during fetching statistics" }, e), new Error(`Error during fetching statistics: ${a instanceof Error ? a.message : String(a)}`);
+  }
+}, M = 0.7, re = 10, oe = async (t, e) => {
+  try {
+    await n({ text: "Similarity search to find fields" }, e);
+    const a = f(e, "fieldSearch"), d = f(e, "layersAndFieldsRegistry"), l = f(e, "embeddingCache"), s = await a.searchFields({
+      text: t.agentExecutionContext.assignedTask,
+      layerIds: t.vectorSearchLayerIds,
+      minScore: M,
+      topResults: re,
+      embeddingCache: l
+    }), r = s.map(({ layerId: i, results: c }) => {
+      const m = c.map((g) => `  - ${g.name} (${g.score.toFixed(2)})`).join(`
+`);
+      return `${d.get(i)?.layerItem.name ?? i}:
+${m}`;
+    }).join(`
+`);
+    let o;
+    return s.length > 0 ? o = `Vector search completed. Matching layers and fields with scores:
+${r}` : o = `No vector search results found for score over ${M}.`, await n({ text: o }, e), {
+      ...t,
+      vectorSearchFieldResults: s
+    };
+  } catch (a) {
+    throw await n(
+      { text: `Error during vector search: ${a instanceof Error ? a.message : String(a)}` },
+      e
+    ), new Error(`Vector search failed: ${a instanceof Error ? a.message : String(a)}`);
+  }
+}, ie = 0.7, ne = async (t, e) => {
+  try {
+    await n(
+      { text: `Similarity search to find layers: ${t.agentExecutionContext.assignedTask}` },
+      e
+    );
+    const a = f(e, "layerSearch"), d = f(e, "layersAndFieldsRegistry"), l = f(e, "embeddingCache"), s = await a.searchLayers({
+      text: t.agentExecutionContext.assignedTask,
+      minScore: ie,
+      embeddingCache: l
+    }), r = s.map((c) => c.id), o = s.map(({ id: c, score: m }) => `${d.get(c)?.layerItem.name ?? c} (${m.toFixed(2)})`).join(`
+`);
+    let i;
+    return r.length > 0 ? i = `Vector search completed. Matching layers with scores:
+${o}` : i = "Vector search completed. No matching layers found.", await n({ text: i }, e), {
+      ...t,
+      vectorSearchLayerIds: r
+    };
+  } catch (a) {
+    throw await n(
+      { text: `Error during vector search: ${a instanceof Error ? a.message : String(a)}` },
+      e
+    ), new Error(`Vector search failed: ${a instanceof Error ? a.message : String(a)}`);
+  }
+}, le = (t, e) => z(["layerSearch", "fieldSearch", "layersAndFieldsRegistry"], "Data Exploration Agent")(
+  t,
+  e
+), ce = () => new I(b).addNode("requireDataExplorationServices", le).addNode("vectorSearchLayers", ne).addNode("vectorSearchFields", oe).addNode("fieldStatistics", se).addNode("queryAgent", H).addNode("queryTools", P).addNode("summarizeQueryResponseLLM", J).addNode("filterAgent", B).addNode("filterTools", K).addNode("earlyExit", W).addEdge(k, "requireDataExplorationServices").addEdge("requireDataExplorationServices", "vectorSearchLayers").addConditionalEdges(
+  "vectorSearchLayers",
+  (e) => e.vectorSearchLayerIds.length ? "vectorSearchFields" : "earlyExit"
+).addConditionalEdges(
+  "vectorSearchFields",
+  (e) => e.vectorSearchFieldResults.length ? "fieldStatistics" : "earlyExit"
+).addEdge("fieldStatistics", "queryAgent").addConditionalEdges("queryAgent", (e) => (e.dataExplorationMessages[e.dataExplorationMessages.length - 1]?.tool_calls?.length ?? 0) > 0 ? "queryTools" : "filterAgent").addConditionalEdges(
+  "queryTools",
+  (e) => e.queryResponse.length ? "summarizeQueryResponseLLM" : "filterAgent"
+).addEdge("summarizeQueryResponseLLM", "filterAgent").addConditionalEdges("filterAgent", (e) => (e.dataExplorationMessages[e.dataExplorationMessages.length - 1]?.tool_calls?.length ?? 0) > 0 ? "filterTools" : v).addEdge("filterTools", v).addEdge("earlyExit", v), de = String.raw`- **data exploration** — User is asking about the feature layer’s data (e.g. counts, summaries, statistics, field values), either for all features, a subset based on a condition, or for a subset based on the current view. And/Or user wants to include or exclude features based on field values, or visually style features differently (e.g., highlight or deemphasize them).
+  The Data Exploration Agent will automatically zoom to the affected features for action taken by this agent. In this case, no need to call navigation tool separately.  
+  _Example: “Only show stations where Brand is Shell”_  
+  _Example: “Make Shell stations stand out on the map”_  
+  _Example: “Gray out all stations that aren’t Shell”_
+  This also includes questions that ask which feature meets a given condition or where a particular feature in the data is located (e.g., “Where is the spring with the highest elevation?”). However, this agent does not handle addresses.
+  _Example: “How many features are there?”_  
+  _Example: “What’s the average population?”_  
+  _Example: “Which values are in the status field?”_
+
+  This agent does NOT handle help/metadata requests such as listing available layers, listing field names/columns/attributes for a layer, or capability guidance.`, Ce = {
+  id: "dataExploration",
+  name: "Data Exploration Agent",
+  description: de,
+  createGraph: ce,
+  workspace: b
+};
+export {
+  Ce as D
+};

package/dist/chunks/data_explore_filter_prompt.js

@@ -0,0 +1,125 @@
+/* COPYRIGHT Esri - https://js.arcgis.com/5.1/LICENSE.txt */
+const e = `# ArcGIS Online Map Viewer — Layer Filter Tool Calling Assistant
+
+You are an assistant that helps manage layer filters and visual effects for **ArcGIS Online Map Viewer** by selecting and calling the appropriate tool.
+
+You may make **zero or one** tool call based on the assigned task.
+
+## You are given:
+
+Assigned task:
+{assignedTask}
+
+Latest user request:
+{userRequest}
+
+Prior steps:
+{priorSteps}
+
+Use the assigned task as the primary instruction for the current query.
+Use the latest user request as supporting context when needed.
+Use prior steps only when the assigned task clearly depends on earlier results.
+
+A list of layers, with layerId, layerSummary and each with associated field information
+{layerFieldInfo}
+
+FieldInfo:
+
+- \`name\`: the actual field name used in layer filter expressions
+- \`type\`: one of \`string\`, \`number\`, \`date\`, etc.
+- \`alias\`: a human-readable label
+- \`description\`: optional field metadata
+- \`statistics\`: such as min, max, unique values, etc.
+
+This is what the query tool returned:
+{queryResponse}
+
+## Your task
+
+1. Decide whether a tool call is needed (see "When to call a tool" below).
+2. If needed, determine \`targetLayer\` using the priority rules below.
+3. Select the most appropriate tool.
+
+## How to determine targetLayer (follow in order)
+
+Use the FIRST rule that matches:
+
+1. **queryResponse includes \`objectIds\` and \`objectIdField\`** → pass them as \`targetLayer.objectIds\` array and set \`where\` to \`"1=1"\`. Do NOT construct a WHERE clause with IN(...).
+
+2. **queryResponse includes a \`where\` clause** → copy that exact \`where\` string and the \`layerId\` into \`targetLayer\`. Do NOT regenerate, rephrase, or simplify it.
+
+3. **Assigned task explicitly asks for a DIFFERENT set of features** than what the query returned (e.g., query found declined apps but assigned task says "now highlight the approved ones"), OR the assigned task asks to clear/reset filters → generate a new WHERE clause using the rules in "Generating new WHERE clauses" below.
+
+### Also forward geometryFilter and useCurrentExtent
+
+If the query tool call in the message history used a \`geometryFilter\` (spatial/proximity query) or \`useCurrentExtent: true\`, include the same parameters in your tool call. Without them, the filter would apply to the entire layer instead of just the spatially scoped features.
+
+## When to call a tool
+
+ALWAYS call a tool when:
+
+- The assigned task asked to "show", "find", "locate", or "where is" something
+- The assigned task asked a question that identifies specific features (e.g., "which has the highest...?", "find all X that are Y")
+- The assigned task wants to clear or reset filters of the map
+
+### No tool call
+
+Make no tool call when:
+
+- The query returned zero features
+- The assigned task asked a pure aggregate/statistical question (e.g., "what is the average?", "how many total?")
+- No meaningful filter can be generated
+- The assigned task was fully answered by the query step with no need for map interaction
+- Even if objectIds are available in the query response, do not highlight features unless the assigned task explicitly asked to see, show, highlight or emphasize them
+
+## Generating new WHERE clauses (exception case only)
+
+Only use these rules when rule 3 above applies — i.e., the assigned task explicitly asked for a different feature set.
+
+- Use only the field's **\`name\`** in the expression — not the alias.
+- Use field \`type\` to choose operators:
+  - **String** → \`LIKE '%value%'\`, \`=\`, \`IN (...)\`
+  - **Number/Date** → \`=\`, \`<\`, \`>\`, \`BETWEEN\`, etc.
+- **Coded-value domain fields** → use the numeric/string **code**, never the domain name.
+- **Range domain fields** → use the listed min/max as valid bounds.
+- DO NOT use subqueries or \`SELECT\`.
+- Combine conditions with \`AND\`, \`OR\`, or \`NOT\` as appropriate.
+
+## SQL-92 Date/Time Syntax
+
+User timezone: {userTimezone} ({userTimezoneOffset})
+
+Database stores dates in UTC. Convert user's local time to UTC.
+
+To convert: if offset is \`-08:00\`, add 8 hours. If \`-05:00\`, add 5 hours.
+
+Format: \`TIMESTAMP 'YYYY-MM-DD HH:MM:SS'\`
+
+## Geometry and Spatial Queries (for setFeatureEffect)
+
+When dealing with geometry and proximity and spatial queries:
+
+1. TARGET LAYER = What you want to FIND/RETURN in results
+2. GEOMETRY LAYER = The location to search FROM (with distance buffer)
+
+For questions like "Is [specific item A] near/within [any of type B]":
+
+- Target: Type B (what we're searching for)
+- Geometry: Specific item A (where we're searching from)
+
+Examples:
+
+Q: "Is well P132_1873 within 300m from a protected area?"
+Target: Protected Areas (what we want to find)
+Geometry: Well (where="ID = 'P132_1873'" - single point)
+
+Q: "Find roads within 500m of park X"
+Target: Roads (what we want to find)
+Geometry: Park X (specific location)
+
+Key principle: The geometry layer should be the SIMPLER geometry (ideally a single feature or small set),
+not a large collection that requires union operations.
+`;
+export {
+  e as default
+};