teraprox-core-sdk 0.3.11 → 0.3.14

package/dist/index.mjs

@@ -4,8 +4,11 @@ import {
   FederatedBridge,
   NullObservabilityAdapter,
   StandaloneProvider,
-  createReducersBundle
-} from "./chunk-JK654W4P.mjs";
+  createReducersBundle,
+  createReducersFromManifest,
+  groupMenuSections,
+  isHostedByCore
+} from "./chunk-CBKXJHPL.mjs";
 
 // src/adapters/null/NullObjectAdapters.ts
 var NullToastService = class {
@@ -75,6 +78,7 @@ var NullCoreService = {
   unsubscribeEvent: (evt) => console.log(`[CoreService Fallback] Desinscri\xE7\xE3o Evento: ${evt}`),
   handleLogout: () => console.log(`[CoreService Fallback] Realizando logout...`),
   hostedByCore: false,
+  rateLimits: {},
   observability: new NullObservabilityAdapter()
 };
 
@@ -169,60 +173,118 @@ var TracingHttpAdapter = class {
 
 // src/factories/CoreServiceBuilder.ts
 var FetchHttpAdapter = class {
-  constructor(endpoint, extraHeaders) {
+  constructor(endpoint, extraHeaders, interceptors) {
     this.endpoint = endpoint;
     this.extraHeaders = extraHeaders;
+    this.interceptors = interceptors;
+  }
+  mergeHeaders(extraReqHeaders, hasJsonBody) {
+    return {
+      ...this.extraHeaders,
+      ...hasJsonBody ? { "Content-Type": "application/json" } : {},
+      ...extraReqHeaders
+    };
   }
-  async request(method, extraPath, data) {
+  /** Join non-empty path segments, avoiding double slashes. */
+  joinPath(...parts) {
+    return parts.filter((p) => p != null && p !== "").map(String).join("/");
+  }
+  async request(method, extraPath, data, extraHeaders) {
     const url = extraPath ? `${this.endpoint}/${extraPath}` : this.endpoint;
+    const isFormData = typeof FormData !== "undefined" && data instanceof FormData;
+    const body = data !== void 0 ? isFormData ? data : JSON.stringify(data) : void 0;
+    const buildHeaders = async () => {
+      var _a;
+      let h = this.mergeHeaders(extraHeaders, data !== void 0 && !isFormData);
+      if ((_a = this.interceptors) == null ? void 0 : _a.onBeforeRequest) {
+        h = await this.interceptors.onBeforeRequest(h);
+      }
+      return h;
+    };
+    let interceptorRetryConsumed = false;
+    const doFetch = async () => {
+      var _a, _b;
+      const headers = await buildHeaders();
+      const res = await fetch(url, { method, headers, body });
+      if (!res.ok) {
+        const errorData = await res.json().catch(() => ({}));
+        if ((_a = this.interceptors) == null ? void 0 : _a.onError) {
+          return this.interceptors.onError(
+            { status: res.status, headers: res.headers, data: errorData, message: `HTTP ${res.status}` },
+            async () => {
+              if (interceptorRetryConsumed) {
+                const e = new Error(`HTTP ${res.status} (retry limit)`);
+                e.status = res.status;
+                e.data = errorData;
+                throw e;
+              }
+              interceptorRetryConsumed = true;
+              return doFetch();
+            }
+          );
+        }
+        throw new Error(`HTTP ${res.status}`);
+      }
+      const responseData = await res.json().catch(() => ({}));
+      if ((_b = this.interceptors) == null ? void 0 : _b.onResponse) {
+        return this.interceptors.onResponse(
+          { status: res.status, headers: res.headers, data: responseData },
+          method
+        );
+      }
+      return responseData;
+    };
+    if (this.interceptors) {
+      return await doFetch();
+    }
     try {
-      const res = await fetch(url, {
-        method,
-        headers: {
-          ...this.extraHeaders,
-          ...data ? { "Content-Type": "application/json" } : {}
-        },
-        body: data ? JSON.stringify(data) : void 0
-      });
-      if (!res.ok) throw new Error(`HTTP ${res.status}`);
-      return await res.json();
+      return await doFetch();
     } catch (e) {
-      console.warn(`[FetchHttpAdapter] Falha ao fazer ${method} para ${url}:`, e);
+      console.warn(`[FetchHttpAdapter] ${method} ${url}:`, e);
       return [];
     }
   }
-  get(path) {
-    return this.request("GET", path || "");
+  qs(query) {
+    return query ? `?${query}` : "";
   }
-  post(path, data) {
-    return this.request("POST", path || "", data);
+  get(path, query) {
+    return this.request("GET", `${this.joinPath(path)}${this.qs(query)}`);
   }
-  put(path, data) {
-    return this.request("PUT", path || "", data);
+  post(path, data, extraHeaders, query) {
+    return this.request("POST", `${this.joinPath(path)}${this.qs(query)}`, data, extraHeaders);
   }
-  patch(path, data) {
-    return this.request("PATCH", path || "", data);
+  put(path, data, extraHeaders, query) {
+    return this.request("PUT", `${this.joinPath(path)}${this.qs(query)}`, data, extraHeaders);
   }
-  delete(path, id) {
-    return this.request("DELETE", `${path || ""}/${id}`);
+  patch(path, data, extraHeaders, query) {
+    return this.request("PATCH", `${this.joinPath(path)}${this.qs(query)}`, data, extraHeaders);
   }
-  deleteSimple(path) {
-    return this.request("DELETE", path || "");
+  delete(path, id, extraHeaders, query) {
+    return this.request("DELETE", `${this.joinPath(path, id)}${this.qs(query)}`, void 0, extraHeaders);
   }
-  save(path, data) {
-    return this.request("POST", path || "", data);
+  deleteSimple(path, extraHeaders, query) {
+    return this.request("DELETE", `${this.joinPath(path)}${this.qs(query)}`, void 0, extraHeaders);
   }
-  read(path, id) {
-    return this.request("GET", `${path || ""}/${id}`);
+  save(path, data, extraHeaders, query) {
+    if (data && (data.id || data._id)) {
+      const id = data.id || data._id;
+      return this.request("PUT", `${this.joinPath(path, id)}${this.qs(query)}`, data, extraHeaders);
+    }
+    return this.request("POST", `${this.joinPath(path)}${this.qs(query)}`, data, extraHeaders);
   }
-  readAll(path) {
-    return this.request("GET", path || "");
+  read(path, id, extraHeaders, query) {
+    return this.request("GET", `${this.joinPath(path, id)}${this.qs(query)}`, void 0, extraHeaders);
   }
-  readAllwithPage(path) {
-    return this.request("GET", path || "");
+  readAll(path, extraHeaders, query) {
+    return this.request("GET", `${this.joinPath(path)}${this.qs(query)}`, void 0, extraHeaders);
   }
-  bulkDelete(path) {
-    return this.request("DELETE", path || "");
+  readAllwithPage(path, page, size) {
+    return this.request("GET", `${this.joinPath(path)}?page=${page}&size=${size}`);
+  }
+  bulkDelete(path, ids, extraHeaders, query) {
+    const bulkParam = ids ? `ids=${ids.join(",")}` : "";
+    const fullQuery = query ? `${query}&${bulkParam}` : bulkParam;
+    return this.request("DELETE", `${this.joinPath(path)}?${fullQuery}`, void 0, extraHeaders);
   }
 };
 var CoreServiceBuilder = class {
@@ -271,6 +333,7 @@ var CoreServiceBuilder = class {
     return this;
   }
   build() {
+    const subscriptions = [];
     return {
       toast: this._toast,
       createController: (context, baseEndPoint) => {
@@ -292,19 +355,27 @@ var CoreServiceBuilder = class {
         const extraHeaders = { "x-teraprox-host": hostHeader };
         return this._tracing ? new TracingHttpAdapter(endpoint, extraHeaders) : new FetchHttpAdapter(endpoint, extraHeaders);
       },
+      // Subscriptions are properly managed so that:
+      // 1. Components using useMatchingObject() have their registrations tracked.
+      // 2. An external RtdbBridge / StandaloneProvider can dispatch to them.
+      // 3. Tests can inspect which subscriptions are active.
       subscribe: (mo) => {
-        console.log(`[CoreServiceBuilder RTDB] Subscribe > ${mo.context}`);
+        subscriptions.push(mo);
       },
       unsubscribe: (mo) => {
-        console.log(`[CoreServiceBuilder RTDB] Unsubscribe > ${mo.context}`);
+        const idx = subscriptions.findIndex(
+          (s) => s.context === mo.context && s.location === mo.location
+        );
+        if (idx >= 0) subscriptions.splice(idx, 1);
       },
-      subscribeEvent: (evt) => {
+      subscribeEvent: (_evt) => {
       },
-      unsubscribeEvent: (evt) => {
+      unsubscribeEvent: (_evt) => {
       },
-      handleLogout: () => console.log("Logout invocado no Standalone mode"),
+      handleLogout: () => console.log("[CoreServiceBuilder] Logout invocado no Standalone mode"),
       hostedByCore: this._hostedByCore,
-      observability: this._observability
+      observability: this._observability,
+      rateLimits: {}
     };
   }
 };
@@ -425,15 +496,207 @@ function useObservability() {
   return useCoreService().observability;
 }
 
+// src/hooks/useAnexoManager.ts
+import { useState, useCallback as useCallback2, useMemo as useMemo2 } from "react";
+function generateLocalId() {
+  return `local_${Date.now()}_${Math.random().toString(36).slice(2, 9)}`;
+}
+function mapRowToPersistido(raw) {
+  var _a, _b, _c, _d;
+  const r = (raw == null ? void 0 : raw.dataValues) != null ? { ...raw.dataValues, id: (_b = raw.id) != null ? _b : (_a = raw.dataValues) == null ? void 0 : _a.id } : raw;
+  if (!r || typeof r !== "object") {
+    return { id: "unknown", nome: "Anexo", tipo: "application/octet-stream" };
+  }
+  const nome = typeof r.nome === "string" && r.nome || typeof r.originalName === "string" && r.originalName || typeof r.fileName === "string" && r.fileName || typeof r.key === "string" && r.key.split("/").pop() || "Anexo";
+  const tipo = typeof r.contentType === "string" && r.contentType || typeof r.tipo === "string" && r.tipo || "application/octet-stream";
+  const id = (_d = (_c = r.id) != null ? _c : r.anexoId) != null ? _d : String(nome);
+  const tamanho = typeof r.size === "number" ? r.size : typeof r.tamanho === "number" ? r.tamanho : void 0;
+  return {
+    id,
+    nome,
+    tipo,
+    tamanho,
+    url: r.url,
+    signedUrl: r.signedUrl,
+    key: r.key,
+    createdAt: r.createdAt
+  };
+}
+function useAnexoManager({ context, entityId, port }) {
+  const { createController } = useCoreService();
+  const [persistidos, setPersistidos] = useState([]);
+  const [locais, setLocais] = useState([]);
+  const [loading, setLoading] = useState(false);
+  const anexoController = useMemo2(() => createController("anexo"), [createController]);
+  const getPort = useCallback2(() => {
+    if (port && typeof port === "object" && "readByEntity" in port) return port;
+    const ctrl = anexoController;
+    return {
+      intent: (params) => ctrl.post("intent", {
+        fileName: params.nome,
+        contentType: params.tipo,
+        size: params.tamanho,
+        dataId: String(params.entityId),
+        dataContext: params.context
+      }),
+      confirm: (params) => {
+        var _a, _b;
+        return ctrl.post("confirm", {
+          key: params.key,
+          fileName: (_a = params.fileName) != null ? _a : "",
+          contentType: (_b = params.contentType) != null ? _b : "",
+          dataId: String(params.entityId),
+          dataContext: params.context
+        });
+      },
+      uploadDirect: async ({ file, context: ctx, entityId: eid }) => {
+        const targetCtrl = createController(ctx);
+        return targetCtrl.put(`anexo/${eid}`, {
+          anexos: [{ nome: file.name, tipo: file.type, tamanho: file.size }]
+        });
+      },
+      readByEntity: (ctx, eid) => ctrl.post("readByData", { dataId: String(eid), dataContext: ctx }),
+      getSignedUrl: (anexoId, key) => key ? ctrl.post("signedUrl", { key }).then((r) => (r == null ? void 0 : r.signedUrl) || (r == null ? void 0 : r.url) || "") : ctrl.post("signedUrl", { anexoId }).then((r) => (r == null ? void 0 : r.url) || (r == null ? void 0 : r.signedUrl) || ""),
+      remove: (anexoId) => ctrl.delete("", anexoId)
+    };
+  }, [port, anexoController, createController]);
+  const loadAnexos = useCallback2(async () => {
+    setLoading(true);
+    try {
+      const data = await getPort().readByEntity(context, entityId);
+      setPersistidos((Array.isArray(data) ? data : []).map(mapRowToPersistido));
+    } catch (e) {
+      setPersistidos([]);
+    } finally {
+      setLoading(false);
+    }
+  }, [context, entityId, getPort]);
+  const addFiles = useCallback2((files) => {
+    const newLocais = files.map((file) => ({
+      localId: generateLocalId(),
+      file,
+      nome: file.name,
+      tipo: file.type,
+      tamanho: file.size,
+      progress: 0,
+      status: "pending"
+    }));
+    setLocais((prev) => [...prev, ...newLocais]);
+  }, []);
+  const removeLocal = useCallback2((localId2) => {
+    setLocais((prev) => prev.filter((a) => a.localId !== localId2));
+  }, []);
+  const uploadAll = useCallback2(async (overrideEntityId) => {
+    var _a, _b;
+    const pending = locais.filter((a) => a.status === "pending" || a.status === "error");
+    if (!pending.length) return [];
+    const eid = overrideEntityId != null ? overrideEntityId : entityId;
+    const results = [];
+    const p = getPort();
+    for (const anexo of pending) {
+      setLocais(
+        (prev) => prev.map((a) => a.localId === anexo.localId ? { ...a, status: "uploading", progress: 10 } : a)
+      );
+      try {
+        let intent = null;
+        try {
+          intent = await p.intent({
+            nome: anexo.nome,
+            tipo: anexo.tipo,
+            tamanho: anexo.tamanho,
+            context,
+            entityId: eid
+          });
+        } catch (e) {
+        }
+        setLocais(
+          (prev) => prev.map((a) => a.localId === anexo.localId ? { ...a, progress: 40 } : a)
+        );
+        let result;
+        const intentUrl = (intent == null ? void 0 : intent.uploadUrl) || (intent == null ? void 0 : intent.signedUrl);
+        if (intentUrl) {
+          const putRes = await fetch(intentUrl, {
+            method: "PUT",
+            body: anexo.file,
+            headers: { "Content-Type": anexo.tipo || "application/octet-stream" }
+          });
+          if (!putRes.ok) {
+            const hint = await putRes.text().catch(() => "");
+            throw new Error(
+              `Falha ao enviar ficheiro para o armazenamento (HTTP ${putRes.status}). ${hint ? hint.slice(0, 180) : ""}`.trim()
+            );
+          }
+          setLocais(
+            (prev) => prev.map((a) => a.localId === anexo.localId ? { ...a, progress: 80 } : a)
+          );
+          result = await p.confirm({
+            context,
+            entityId: eid,
+            key: intent.key,
+            fileName: (_a = intent.fileName) != null ? _a : anexo.nome,
+            contentType: (_b = intent.contentType) != null ? _b : anexo.tipo
+          });
+        } else {
+          result = await p.uploadDirect({ file: anexo.file, context, entityId: eid });
+        }
+        setLocais(
+          (prev) => prev.map((a) => a.localId === anexo.localId ? { ...a, status: "done", progress: 100 } : a)
+        );
+        results.push(mapRowToPersistido(result));
+      } catch (err) {
+        setLocais(
+          (prev) => prev.map(
+            (a) => a.localId === anexo.localId ? { ...a, status: "error", progress: 0, errorMessage: (err == null ? void 0 : err.message) || "Falha no upload" } : a
+          )
+        );
+      }
+    }
+    if (results.length) {
+      setPersistidos((prev) => [...prev, ...results]);
+      setLocais((prev) => prev.filter((a) => a.status !== "done"));
+    }
+    return results;
+  }, [locais, getPort, context, entityId]);
+  const removePersistido = useCallback2(async (anexoId) => {
+    try {
+      await getPort().remove(anexoId);
+      setPersistidos((prev) => prev.filter((a) => a.id !== anexoId));
+    } catch (e) {
+    }
+  }, [getPort]);
+  const getUrl = useCallback2(
+    async (anexoId, key) => {
+      let k = key;
+      if (k == null || k === "") {
+        const p = persistidos.find((a) => String(a.id) === String(anexoId));
+        k = p == null ? void 0 : p.key;
+      }
+      return getPort().getSignedUrl(anexoId, k);
+    },
+    [getPort, persistidos]
+  );
+  return {
+    persistidos,
+    locais,
+    loading,
+    loadAnexos,
+    addFiles,
+    removeLocal,
+    uploadAll,
+    removePersistido,
+    getUrl
+  };
+}
+
 // src/hooks/useFetchData.ts
-import { useState, useCallback as useCallback2, useRef } from "react";
+import { useState as useState2, useCallback as useCallback3, useRef } from "react";
 function useFetchData() {
   const { createController } = useCoreService();
-  const [data, setData] = useState(null);
-  const [loading, setLoading] = useState(false);
-  const [error, setError] = useState(null);
+  const [data, setData] = useState2(null);
+  const [loading, setLoading] = useState2(false);
+  const [error, setError] = useState2(null);
   const activeRef = useRef(true);
-  const fetchData = useCallback2(
+  const fetchData = useCallback3(
     async (context, path, endpoint) => {
       const controller = createController(context, endpoint);
       setLoading(true);
@@ -451,7 +714,7 @@ function useFetchData() {
     },
     [createController]
   );
-  const reset = useCallback2(() => {
+  const reset = useCallback3(() => {
     setData(null);
     setLoading(false);
     setError(null);
@@ -460,13 +723,13 @@ function useFetchData() {
 }
 
 // src/hooks/usePostData.ts
-import { useState as useState2, useCallback as useCallback3 } from "react";
+import { useState as useState3, useCallback as useCallback4 } from "react";
 function usePostData() {
   const { createController } = useCoreService();
-  const [result, setResult] = useState2(null);
-  const [loading, setLoading] = useState2(false);
-  const [error, setError] = useState2(null);
-  const postData = useCallback3(
+  const [result, setResult] = useState3(null);
+  const [loading, setLoading] = useState3(false);
+  const [error, setError] = useState3(null);
+  const postData = useCallback4(
     async (context, path, payload, endpoint) => {
       const controller = createController(context, endpoint);
       setLoading(true);
@@ -488,13 +751,13 @@ function usePostData() {
 }
 
 // src/hooks/useAnexoUpload.ts
-import { useState as useState3, useCallback as useCallback4 } from "react";
+import { useState as useState4, useCallback as useCallback5 } from "react";
 function useAnexoUpload() {
   const { createController } = useCoreService();
   const toast = useToast();
-  const [uploading, setUploading] = useState3(false);
-  const [progress, setProgress] = useState3(0);
-  const upload = useCallback4(
+  const [uploading, setUploading] = useState4(false);
+  const [progress, setProgress] = useState4(0);
+  const upload = useCallback5(
     async (context, path, file, extraHeaders) => {
       const controller = createController(context);
       setUploading(true);
@@ -517,7 +780,7 @@ function useAnexoUpload() {
     },
     [createController, toast]
   );
-  const uploadMultiple = useCallback4(
+  const uploadMultiple = useCallback5(
     async (context, path, files, extraHeaders) => {
       const fileArray = Array.from(files);
       const results = [];
@@ -535,10 +798,10 @@ function useAnexoUpload() {
 }
 
 // src/hooks/useFormStorage.ts
-import { useState as useState4, useCallback as useCallback5, useEffect as useEffect2 } from "react";
+import { useState as useState5, useCallback as useCallback6, useEffect as useEffect2 } from "react";
 function useFormStorage(key, initialValue) {
   const storageKey = `teraprox_form_${key}`;
-  const [value, setValue] = useState4(() => {
+  const [value, setValue] = useState5(() => {
     try {
       const stored = localStorage.getItem(storageKey);
       return stored ? JSON.parse(stored) : initialValue;
@@ -552,7 +815,7 @@ function useFormStorage(key, initialValue) {
     } catch (e) {
     }
   }, [value, storageKey]);
-  const clear = useCallback5(() => {
+  const clear = useCallback6(() => {
     localStorage.removeItem(storageKey);
     setValue(initialValue);
   }, [storageKey, initialValue]);
@@ -560,11 +823,11 @@ function useFormStorage(key, initialValue) {
 }
 
 // src/hooks/useSmartSearch.ts
-import { useState as useState5, useMemo as useMemo2, useCallback as useCallback6 } from "react";
+import { useState as useState6, useMemo as useMemo3, useCallback as useCallback7 } from "react";
 function useSmartSearch(data, searchFields, options) {
-  const [searchTerm, setSearchTerm] = useState5("");
+  const [searchTerm, setSearchTerm] = useState6("");
   const { caseSensitive = false, minLength = 1 } = options || {};
-  const filteredData = useMemo2(() => {
+  const filteredData = useMemo3(() => {
     if (!searchTerm || searchTerm.length < minLength) return data;
     const term = caseSensitive ? searchTerm : searchTerm.toLowerCase();
     return data.filter(
@@ -576,16 +839,16 @@ function useSmartSearch(data, searchFields, options) {
       })
     );
   }, [data, searchTerm, searchFields, caseSensitive, minLength]);
-  const clearSearch = useCallback6(() => setSearchTerm(""), []);
+  const clearSearch = useCallback7(() => setSearchTerm(""), []);
   return { searchTerm, setSearchTerm, filteredData, clearSearch };
 }
 
 // src/hooks/useValidation.ts
-import { useState as useState6, useCallback as useCallback7 } from "react";
+import { useState as useState7, useCallback as useCallback8 } from "react";
 function useValidation(rules) {
   const toast = useToast();
-  const [errors, setErrors] = useState6({});
-  const validate = useCallback7(
+  const [errors, setErrors] = useState7({});
+  const validate = useCallback8(
     (form) => {
       const newErrors = {};
       let valid = true;
@@ -604,22 +867,523 @@ function useValidation(rules) {
     },
     [rules, toast]
   );
-  const clearErrors = useCallback7(() => setErrors({}), []);
-  const setFieldError = useCallback7(
+  const clearErrors = useCallback8(() => setErrors({}), []);
+  const setFieldError = useCallback8(
     (field, message) => setErrors((prev) => ({ ...prev, [field]: message })),
     []
   );
   return { errors, validate, clearErrors, setFieldError };
 }
 
-// src/components/recurso/RecursoDisplayer.tsx
-import { useEffect as useEffect6, useState as useState12 } from "react";
-import { Button } from "react-bootstrap";
-import { useDispatch as useDispatch2 } from "react-redux";
+// src/hooks/useTimeFormat.ts
+import dayjs from "dayjs";
+import duration from "dayjs/plugin/duration.js";
+dayjs.extend(duration);
+var secondsToHms = (seconds) => {
+  const s = typeof seconds === "number" && !Number.isNaN(seconds) ? seconds : 0;
+  return dayjs.duration(s, "seconds").format("HH:mm:ss");
+};
+var hmsToSeconds = (value) => {
+  if (!value) return null;
+  const parts = value.split(":").map(Number);
+  const [h = 0, m = 0, s = 0] = parts;
+  if ([h, m, s].some(Number.isNaN)) return null;
+  return h * 3600 + m * 60 + s;
+};
+var useTimeFormat = () => ({
+  secondsToHms,
+  hmsToSeconds
+});
 
-// src/reducers/branchLevelReducer.ts
+// src/hooks/useFilterCombineMode.ts
+import { useCallback as useCallback9, useMemo as useMemo4, useState as useState8 } from "react";
+var FILTER_COMBINE_MODES = [
+  "union",
+  "intersection",
+  "xor"
+];
+var nextMode = {
+  union: "intersection",
+  intersection: "xor",
+  xor: "union"
+};
+function useFilterCombineMode(initialMode = "union") {
+  const [mode, setMode] = useState8(initialMode);
+  const cycleMode = useCallback9(() => {
+    setMode((prev) => nextMode[prev]);
+  }, []);
+  const matches = useCallback9(
+    (predicates, item) => {
+      if (!predicates || predicates.length === 0) return true;
+      if (mode === "union") {
+        for (let i = 0; i < predicates.length; i++) {
+          if (predicates[i](item)) return true;
+        }
+        return false;
+      }
+      if (mode === "intersection") {
+        for (let i = 0; i < predicates.length; i++) {
+          if (!predicates[i](item)) return false;
+        }
+        return true;
+      }
+      let hits = 0;
+      for (let i = 0; i < predicates.length; i++) {
+        if (predicates[i](item)) hits++;
+      }
+      return hits % 2 === 1;
+    },
+    [mode]
+  );
+  return useMemo4(
+    () => ({ mode, setMode, cycleMode, matches }),
+    [mode, cycleMode, matches]
+  );
+}
+
+// src/viewmodels/ReduxUnidadeMaterialAdapter.ts
+import { useCallback as useCallback10, useMemo as useMemo5, useState as useState9 } from "react";
+import { useDispatch as useDispatch2, useSelector as useSelector3 } from "react-redux";
+
+// src/viewmodels/unidadeMaterialSlice.ts
 import { createSlice } from "@reduxjs/toolkit";
+var DEFAULT_KEY = "__default__";
+var emptyValue = {
+  material: null,
+  quantidade: "",
+  unidade: null
+};
 var initialState = {
+  byTarefa: {}
+};
+var keyOf = (tarefaId) => tarefaId === void 0 || tarefaId === null || tarefaId === "" ? DEFAULT_KEY : String(tarefaId);
+var ensure = (state, key) => {
+  if (!state.byTarefa[key]) {
+    state.byTarefa[key] = { ...emptyValue };
+  }
+  return state.byTarefa[key];
+};
+var unidadeMaterialSlice = createSlice({
+  name: "unidadeMaterialVm",
+  initialState,
+  reducers: {
+    setMaterial(state, action) {
+      const key = keyOf(action.payload.tarefaId);
+      ensure(state, key).material = action.payload.value;
+    },
+    setQuantidade(state, action) {
+      const key = keyOf(action.payload.tarefaId);
+      ensure(state, key).quantidade = action.payload.value;
+    },
+    setUnidade(state, action) {
+      const key = keyOf(action.payload.tarefaId);
+      ensure(state, key).unidade = action.payload.value;
+    },
+    populate(state, action) {
+      const key = keyOf(action.payload.tarefaId);
+      state.byTarefa[key] = { ...emptyValue, ...action.payload.value };
+    },
+    clearUnidadeMaterial(state, action) {
+      var _a;
+      const key = keyOf((_a = action.payload) == null ? void 0 : _a.tarefaId);
+      state.byTarefa[key] = { ...emptyValue };
+    }
+  }
+});
+var {
+  setMaterial,
+  setQuantidade,
+  setUnidade,
+  populate: populateUnidadeMaterial,
+  clearUnidadeMaterial
+} = unidadeMaterialSlice.actions;
+var selectUnidadeMaterial = (state, tarefaId) => {
+  var _a, _b, _c;
+  const key = keyOf(tarefaId);
+  const slice3 = (_a = state == null ? void 0 : state.unidadeMaterialVm) != null ? _a : state == null ? void 0 : state.unidadeMaterial;
+  return (_c = (_b = slice3 == null ? void 0 : slice3.byTarefa) == null ? void 0 : _b[key]) != null ? _c : emptyValue;
+};
+var unidadeMaterialSlice_default = unidadeMaterialSlice.reducer;
+
+// src/viewmodels/ReduxUnidadeMaterialAdapter.ts
+function runValidate(value) {
+  const errors = {};
+  if (!(value == null ? void 0 : value.material)) {
+    errors.material = "O material \xE9 obrigat\xF3rio.";
+  }
+  if (!(value == null ? void 0 : value.unidade)) {
+    errors.unidade = "A unidade \xE9 obrigat\xF3ria.";
+  }
+  const qtd = value == null ? void 0 : value.quantidade;
+  const qtdNum = typeof qtd === "number" ? qtd : Number(qtd);
+  if (qtd === "" || qtd === null || qtd === void 0 || isNaN(qtdNum) || qtdNum <= 0) {
+    errors.quantidade = "A quantidade deve ser um n\xFAmero maior que zero.";
+  }
+  return { ok: Object.keys(errors).length === 0, errors };
+}
+function useUnidadeMaterialViewModel(tarefaId) {
+  const dispatch = useDispatch2();
+  const toast = useToast();
+  const materialCtrl = useHttpController("material");
+  const unidadeCtrl = useHttpController("unidade");
+  const tarefaUnidadeMaterialCtrl = useHttpController("tarefaUnidadeMaterial");
+  const value = useSelector3(
+    (state) => selectUnidadeMaterial(state, tarefaId)
+  );
+  const [isSubmitting, setIsSubmitting] = useState9(false);
+  const onMaterialSelected = useCallback10(
+    (material) => {
+      dispatch(setMaterial({ tarefaId, value: material != null ? material : null }));
+    },
+    [dispatch, tarefaId]
+  );
+  const onQuantidadeUpdate = useCallback10(
+    (qtd) => {
+      dispatch(setQuantidade({ tarefaId, value: qtd }));
+    },
+    [dispatch, tarefaId]
+  );
+  const onUnidadeSelected = useCallback10(
+    (unidade) => {
+      dispatch(setUnidade({ tarefaId, value: unidade != null ? unidade : null }));
+    },
+    [dispatch, tarefaId]
+  );
+  const loadMaterials = useCallback10(async () => {
+    var _a;
+    const res = await materialCtrl.readAll();
+    return Array.isArray(res) ? res : (_a = res == null ? void 0 : res.data) != null ? _a : [];
+  }, [materialCtrl]);
+  const loadUnidades = useCallback10(async () => {
+    var _a;
+    const res = await unidadeCtrl.readAll();
+    return Array.isArray(res) ? res : (_a = res == null ? void 0 : res.data) != null ? _a : [];
+  }, [unidadeCtrl]);
+  const clear = useCallback10(() => {
+    dispatch(clearUnidadeMaterial({ tarefaId }));
+  }, [dispatch, tarefaId]);
+  const populate = useCallback10(
+    (next) => {
+      dispatch(populateUnidadeMaterial({ tarefaId, value: next }));
+    },
+    [dispatch, tarefaId]
+  );
+  const validate = useCallback10(() => {
+    return runValidate(value);
+  }, [value]);
+  const reset = useCallback10(() => {
+    dispatch(clearUnidadeMaterial({ tarefaId }));
+  }, [dispatch, tarefaId]);
+  const submit = useCallback10(async () => {
+    var _a;
+    setIsSubmitting(true);
+    try {
+      const result = runValidate(value);
+      if (!result.ok) {
+        const firstErr = (_a = Object.values(result.errors)[0]) != null ? _a : "Dados invalidos.";
+        throw new Error(firstErr);
+      }
+      return value;
+    } finally {
+      setIsSubmitting(false);
+    }
+  }, [value]);
+  const updateQuantidade = useCallback10(
+    async (tumId, quantidade) => {
+      try {
+        const body = {
+          quantidade
+        };
+        if (tarefaId !== void 0 && tarefaId !== null) {
+          body.tarefaId = tarefaId;
+        }
+        await tarefaUnidadeMaterialCtrl.put(String(tumId), body);
+      } catch (err) {
+        const msg = (err == null ? void 0 : err.message) || "Nao foi possivel atualizar a quantidade do material.";
+        try {
+          toast.warning(msg);
+        } catch (e) {
+        }
+        throw err;
+      }
+    },
+    [tarefaUnidadeMaterialCtrl, tarefaId, toast]
+  );
+  const isValid = useMemo5(() => runValidate(value).ok, [value]);
+  return useMemo5(
+    () => ({
+      value,
+      isValid,
+      isSubmitting,
+      onMaterialSelected,
+      onQuantidadeUpdate,
+      onUnidadeSelected,
+      loadMaterials,
+      loadUnidades,
+      clear,
+      populate,
+      validate,
+      submit,
+      reset,
+      updateQuantidade
+    }),
+    [
+      value,
+      isValid,
+      isSubmitting,
+      onMaterialSelected,
+      onQuantidadeUpdate,
+      onUnidadeSelected,
+      loadMaterials,
+      loadUnidades,
+      clear,
+      populate,
+      validate,
+      submit,
+      reset,
+      updateQuantidade
+    ]
+  );
+}
+
+// src/viewmodels/ReduxInspecaoModalAdapter.ts
+import { useCallback as useCallback11, useMemo as useMemo6, useState as useState10 } from "react";
+import { useDispatch as useDispatch3, useSelector as useSelector4 } from "react-redux";
+
+// src/viewmodels/inspecaoModalSlice.ts
+import { createSlice as createSlice2 } from "@reduxjs/toolkit";
+var DEFAULT_KEY2 = "__default__";
+var emptyValue2 = {
+  tipo: "",
+  nomeParametro: "",
+  unidadeParametro: "",
+  parametroId: "",
+  limitesDeControle: []
+};
+var initialState2 = {
+  byTarefa: {}
+};
+var keyOf2 = (tarefaId) => tarefaId === void 0 || tarefaId === null || tarefaId === "" ? DEFAULT_KEY2 : String(tarefaId);
+var ensure2 = (state, key) => {
+  if (!state.byTarefa[key]) {
+    state.byTarefa[key] = { ...emptyValue2, limitesDeControle: [] };
+  }
+  return state.byTarefa[key];
+};
+var inspecaoModalSlice = createSlice2({
+  name: "inspecaoModalVm",
+  initialState: initialState2,
+  reducers: {
+    setTipo(state, action) {
+      const key = keyOf2(action.payload.tarefaId);
+      ensure2(state, key).tipo = action.payload.value;
+    },
+    setNomeParametro(state, action) {
+      const key = keyOf2(action.payload.tarefaId);
+      ensure2(state, key).nomeParametro = action.payload.value;
+    },
+    setUnidadeParametro(state, action) {
+      const key = keyOf2(action.payload.tarefaId);
+      ensure2(state, key).unidadeParametro = action.payload.value;
+    },
+    setParametro(state, action) {
+      var _a, _b, _c, _d, _e, _f, _g, _h;
+      const key = keyOf2(action.payload.tarefaId);
+      const slot = ensure2(state, key);
+      const p = (_a = action.payload.value) != null ? _a : {};
+      slot.nomeParametro = (_c = (_b = p.nome) != null ? _b : p.nomeParametro) != null ? _c : "";
+      slot.unidadeParametro = (_f = (_e = (_d = p.labelUnidade) != null ? _d : p.unidade) != null ? _e : p.unidadeParametro) != null ? _f : "";
+      slot.parametroId = (_h = (_g = p.id) != null ? _g : p.parametroId) != null ? _h : "";
+    },
+    setLimites(state, action) {
+      var _a;
+      const key = keyOf2(action.payload.tarefaId);
+      ensure2(state, key).limitesDeControle = (_a = action.payload.value) != null ? _a : [];
+    },
+    removeLimiteAt(state, action) {
+      var _a;
+      const key = keyOf2(action.payload.tarefaId);
+      const slot = ensure2(state, key);
+      const { idx } = action.payload;
+      if ((_a = slot.limitesDeControle) == null ? void 0 : _a[idx]) {
+        slot.limitesDeControle[idx] = {
+          ...slot.limitesDeControle[idx],
+          removed: true
+        };
+      }
+    },
+    populate(state, action) {
+      var _a, _b;
+      const key = keyOf2(action.payload.tarefaId);
+      state.byTarefa[key] = {
+        ...emptyValue2,
+        ...action.payload.value,
+        limitesDeControle: (_b = (_a = action.payload.value) == null ? void 0 : _a.limitesDeControle) != null ? _b : []
+      };
+    },
+    clearInspecaoModal(state, action) {
+      var _a;
+      const key = keyOf2((_a = action.payload) == null ? void 0 : _a.tarefaId);
+      state.byTarefa[key] = { ...emptyValue2, limitesDeControle: [] };
+    }
+  }
+});
+var {
+  setTipo: setInspecaoTipo,
+  setNomeParametro: setInspecaoNomeParametro,
+  setUnidadeParametro: setInspecaoUnidadeParametro,
+  setParametro: setInspecaoParametro,
+  setLimites: setInspecaoLimites,
+  removeLimiteAt: removeInspecaoLimiteAt,
+  populate: populateInspecaoModal,
+  clearInspecaoModal
+} = inspecaoModalSlice.actions;
+var selectInspecaoModal = (state, tarefaId) => {
+  var _a, _b, _c;
+  const key = keyOf2(tarefaId);
+  const slice3 = (_a = state == null ? void 0 : state.inspecaoModalVm) != null ? _a : state == null ? void 0 : state.inspecaoModal;
+  return (_c = (_b = slice3 == null ? void 0 : slice3.byTarefa) == null ? void 0 : _b[key]) != null ? _c : { ...emptyValue2, limitesDeControle: [] };
+};
+var inspecaoModalSlice_default = inspecaoModalSlice.reducer;
+
+// src/viewmodels/ReduxInspecaoModalAdapter.ts
+var TIPO_NUMERICO = "Numerico";
+var TIPO_NUMERICO_ACENTUADO = "Num\xE9rico";
+function isNumericoTipo(tipo) {
+  if (!tipo) return false;
+  const normalized = tipo.trim();
+  return normalized === TIPO_NUMERICO || normalized === TIPO_NUMERICO_ACENTUADO || normalized.toLowerCase() === "numerico" || normalized.toLowerCase() === "num\xE9rico";
+}
+function runValidate2(value) {
+  var _a;
+  const errors = {};
+  if (!(value == null ? void 0 : value.tipo) || String(value.tipo).trim() === "") {
+    errors.tipo = "O tipo de dado \xE9 obrigat\xF3rio.";
+  }
+  if (isNumericoTipo(value == null ? void 0 : value.tipo)) {
+    const ativos = ((_a = value == null ? void 0 : value.limitesDeControle) != null ? _a : []).filter(
+      (l) => l && l.removed !== true
+    );
+    if (ativos.length === 0) {
+      errors.limitesDeControle = "Adicione ao menos um limite de controle para par\xE2metros num\xE9ricos.";
+    }
+  }
+  return { ok: Object.keys(errors).length === 0, errors };
+}
+function useInspecaoModalViewModel(tarefaId) {
+  const dispatch = useDispatch3();
+  const value = useSelector4(
+    (state) => selectInspecaoModal(state, tarefaId)
+  );
+  const [isSubmitting, setIsSubmitting] = useState10(false);
+  const onTipoDeDado = useCallback11(
+    (tipo) => {
+      dispatch(setInspecaoTipo({ tarefaId, value: tipo }));
+    },
+    [dispatch, tarefaId]
+  );
+  const onNomeParametro = useCallback11(
+    (nome) => {
+      dispatch(setInspecaoNomeParametro({ tarefaId, value: nome }));
+    },
+    [dispatch, tarefaId]
+  );
+  const onParametroSelected = useCallback11(
+    (parametro) => {
+      dispatch(setInspecaoParametro({ tarefaId, value: parametro }));
+    },
+    [dispatch, tarefaId]
+  );
+  const onUnidadeParametro = useCallback11(
+    (unidade) => {
+      dispatch(setInspecaoUnidadeParametro({ tarefaId, value: unidade }));
+    },
+    [dispatch, tarefaId]
+  );
+  const onLimitesChange = useCallback11(
+    (limites) => {
+      dispatch(setInspecaoLimites({ tarefaId, value: limites }));
+    },
+    [dispatch, tarefaId]
+  );
+  const removeLimite = useCallback11(
+    (idx) => {
+      dispatch(removeInspecaoLimiteAt({ tarefaId, idx }));
+    },
+    [dispatch, tarefaId]
+  );
+  const editLimite = useCallback11((_limite) => {
+  }, []);
+  const validate = useCallback11(() => {
+    return runValidate2(value);
+  }, [value]);
+  const reset = useCallback11(() => {
+    dispatch(clearInspecaoModal({ tarefaId }));
+  }, [dispatch, tarefaId]);
+  const populateFromExisting = useCallback11(
+    (inspecao) => {
+      dispatch(populateInspecaoModal({ tarefaId, value: inspecao }));
+    },
+    [dispatch, tarefaId]
+  );
+  const submit = useCallback11(async () => {
+    var _a;
+    setIsSubmitting(true);
+    try {
+      const result = runValidate2(value);
+      if (!result.ok) {
+        const firstErr = (_a = Object.values(result.errors)[0]) != null ? _a : "Dados invalidos.";
+        throw new Error(firstErr);
+      }
+      return value;
+    } finally {
+      setIsSubmitting(false);
+    }
+  }, [value]);
+  const isValid = useMemo6(() => runValidate2(value).ok, [value]);
+  return useMemo6(
+    () => ({
+      value,
+      isValid,
+      isSubmitting,
+      onTipoDeDado,
+      onNomeParametro,
+      onParametroSelected,
+      onUnidadeParametro,
+      onLimitesChange,
+      removeLimite,
+      editLimite,
+      validate,
+      submit,
+      reset,
+      populateFromExisting
+    }),
+    [
+      value,
+      isValid,
+      isSubmitting,
+      onTipoDeDado,
+      onNomeParametro,
+      onParametroSelected,
+      onUnidadeParametro,
+      onLimitesChange,
+      removeLimite,
+      editLimite,
+      validate,
+      submit,
+      reset,
+      populateFromExisting
+    ]
+  );
+}
+
+// src/viewmodels/ReduxRecursoDisplayerAdapter.ts
+import { useCallback as useCallback12, useEffect as useEffect3, useMemo as useMemo7, useRef as useRef2, useState as useState11 } from "react";
+import { useDispatch as useDispatch4 } from "react-redux";
+
+// src/reducers/branchLevelReducer.ts
+import { createSlice as createSlice3 } from "@reduxjs/toolkit";
+var initialState3 = {
   form: {
     nome: "",
     level: 0,
@@ -629,9 +1393,9 @@ var initialState = {
   },
   levels: []
 };
-var branchLevelSlice = createSlice({
+var branchLevelSlice = createSlice3({
   name: "branchLevelReducer",
-  initialState,
+  initialState: initialState3,
   reducers: {
     setNome(state, action) {
       state.form.nome = action.payload;
@@ -655,7 +1419,7 @@ var branchLevelSlice = createSlice({
       state.form = action.payload;
     },
     clear(state) {
-      state.form = initialState.form;
+      state.form = initialState3.form;
     }
   }
 });
@@ -671,788 +1435,1282 @@ var {
 } = branchLevelSlice.actions;
 var branchLevelReducer_default = branchLevelSlice.reducer;
 
-// src/components/recurso/BranchDropDisplay.tsx
-import { useEffect as useEffect3, useRef as useRef2, useState as useState7 } from "react";
-import { FaCheck, FaCheckSquare, FaSearch, FaChevronDown } from "react-icons/fa";
-import { MdClose } from "react-icons/md";
-
-// src/utils/colorUtils.ts
-function pickTextColorBasedOnBgColorAdvanced(bgColor, lightColor, darkColor) {
-  const color = bgColor.charAt(0) === "#" ? bgColor.substring(1, 7) : bgColor;
-  const r = parseInt(color.substring(0, 2), 16);
-  const g = parseInt(color.substring(2, 4), 16);
-  const b = parseInt(color.substring(4, 6), 16);
-  const uicolors = [r / 255, g / 255, b / 255];
-  const c = uicolors.map(
-    (col) => col <= 0.03928 ? col / 12.92 : Math.pow((col + 0.055) / 1.055, 2.4)
-  );
-  const L = 0.2126 * c[0] + 0.7152 * c[1] + 0.0722 * c[2];
-  return L > 0.179 ? darkColor : lightColor;
-}
-
-// src/components/recurso/BranchDropDisplay.tsx
-import { jsx, jsxs } from "react/jsx-runtime";
-var BranchDropDisplay = ({
-  branch,
-  addBranch,
-  multiMode,
-  setMultiMode,
-  onSaveRecurso,
-  backOnBranch,
-  branches,
-  singleReturn
-}) => {
-  const [fontColor, setFontColor] = useState7("#000");
-  const [searchTerm, setSearchTerm] = useState7("");
-  const [show, setShow] = useState7(false);
-  const [multiSelected, setMultiSelected] = useState7([]);
-  const dropdownRef = useRef2(null);
+// src/viewmodels/ReduxRecursoDisplayerAdapter.ts
+function useRecursoDisplayerViewModel(overrides = {}) {
+  var _a, _b;
+  const dispatch = useDispatch4();
+  const defaultArvore = useHttpController("");
+  const defaultBranchLevel = useHttpController("branchLevel");
+  const arvoreCtrl = (_a = overrides.arvoreEstruturalController) != null ? _a : defaultArvore;
+  const branchLevelCtrl = (_b = overrides.branchLevelController) != null ? _b : defaultBranchLevel;
+  const [branches, setBranches] = useState11([]);
+  const [isLoading, setIsLoading] = useState11(false);
+  const branchesRef = useRef2(branches);
   useEffect3(() => {
-    setFontColor(
-      pickTextColorBasedOnBgColorAdvanced(branch.branchLevel.color, "#FFFFFF", "#000000")
-    );
-  }, [branch.branchLevel.color]);
-  useEffect3(() => {
-    const handleClickOutside = (event) => {
-      if (dropdownRef.current && !dropdownRef.current.contains(event.target)) {
-        setShow(false);
+    branchesRef.current = branches;
+  }, [branches]);
+  const loadInitialBranches = useCallback12(async () => {
+    setIsLoading(true);
+    try {
+      try {
+        const b = await arvoreCtrl.get("branchByBranchLevel/1");
+        setBranches(Array.isArray(b) ? b : []);
+      } catch (err) {
+        console.warn("[RecursoDisplayerVM] branchByBranchLevel/1 failed:", err);
+        setBranches([]);
       }
-    };
-    document.addEventListener("mousedown", handleClickOutside);
-    return () => document.removeEventListener("mousedown", handleClickOutside);
-  }, [backOnBranch, branch]);
-  const handleItemClick = (bn) => {
-    const rec = bn.recurso;
-    if (multiMode) {
-      setMultiSelected(
-        (prev) => prev.some((r) => r.id === rec.id) ? prev.filter((r) => r.id !== rec.id) : [...prev, rec]
-      );
-    } else {
-      onSaveRecurso([rec]);
-      addBranch(bn);
-      setShow(false);
+      try {
+        const lv = await branchLevelCtrl.readAll();
+        dispatch(setLevels(Array.isArray(lv) ? lv : []));
+      } catch (err) {
+        console.warn("[RecursoDisplayerVM] branchLevel.readAll failed:", err);
+      }
+    } finally {
+      setIsLoading(false);
     }
-  };
-  const startMulti = () => {
-    setMultiSelected([]);
-    setMultiMode(true);
-    setShow(true);
-  };
-  const handleConfirm = () => {
-    setMultiMode(false);
-    onSaveRecurso(multiSelected);
-    setMultiSelected([]);
-    setShow(false);
-  };
-  const cancelMulti = () => {
-    setMultiMode(false);
-    setMultiSelected([]);
-  };
-  const isLastBranchClicked = () => branches.length > 0 && branches[branches.length - 1].id === branch.id;
-  const visibleNodes = (branch.branchNodes || []).filter(
-    (bn) => bn.recurso.nome.toLowerCase().includes(searchTerm.toLowerCase())
-  );
-  return /* @__PURE__ */ jsxs(
-    "div",
-    {
-      ref: dropdownRef,
-      style: {
-        position: "relative",
-        marginBottom: "0.5rem",
-        width: "100%",
-        fontFamily: "Arial, sans-serif"
-      },
-      children: [
-        /* @__PURE__ */ jsxs(
-          "button",
-          {
-            onClick: () => setShow((s) => !s),
-            style: {
-              width: "100%",
-              display: "flex",
-              alignItems: "center",
-              justifyContent: "space-between",
-              padding: "0.5rem 1rem",
-              borderRadius: "9999px",
-              boxShadow: "0 1px 3px rgba(0, 0, 0, 0.1)",
-              border: `1px solid ${branch.branchLevel.color}`,
-              background: branch.branchLevel.color,
-              color: fontColor,
-              cursor: "pointer",
-              outline: "none",
-              textAlign: "left",
-              fontSize: "1rem"
-            },
-            children: [
-              /* @__PURE__ */ jsxs("span", { style: { overflow: "hidden", textOverflow: "ellipsis", whiteSpace: "nowrap" }, children: [
-                branch.nomeRecurso || branch.branchLevel.nome,
-                branch.nomeRecurso && !multiMode && isLastBranchClicked() && /* @__PURE__ */ jsx("em", { style: { fontStyle: "italic", opacity: 0.8, marginLeft: "0.5rem" }, children: "(Selecionado)" })
-              ] }),
-              /* @__PURE__ */ jsx(FaChevronDown, {})
-            ]
-          }
-        ),
-        show && /* @__PURE__ */ jsxs(
-          "div",
-          {
-            style: {
-              position: "absolute",
-              top: "100%",
-              left: 0,
-              width: "100%",
-              background: "#f0f0f0",
-              borderRadius: "8px",
-              boxShadow: "0 2px 6px rgba(0, 0, 0, 0.15)",
-              marginTop: "0.25rem",
-              zIndex: 100,
-              maxHeight: "300px",
-              overflow: "auto"
-            },
-            children: [
-              /* @__PURE__ */ jsxs(
-                "div",
-                {
-                  style: {
-                    display: "flex",
-                    alignItems: "center",
-                    padding: "0.5rem",
-                    borderBottom: "1px solid #ddd"
-                  },
-                  children: [
-                    /* @__PURE__ */ jsx(FaSearch, { style: { marginRight: "0.5rem", color: "#555" } }),
-                    /* @__PURE__ */ jsx(
-                      "input",
-                      {
-                        type: "text",
-                        placeholder: "Pesquisar recurso...",
-                        value: searchTerm,
-                        onChange: (e) => setSearchTerm(e.target.value),
-                        style: {
-                          flex: 1,
-                          padding: "0.5rem",
-                          border: "1px solid #ccc",
-                          borderRadius: "9999px",
-                          outline: "none",
-                          fontSize: "0.95rem"
-                        }
-                      }
-                    )
-                  ]
-                }
-              ),
-              !multiMode && !singleReturn ? /* @__PURE__ */ jsxs(
-                "button",
-                {
-                  onClick: startMulti,
-                  style: {
-                    display: "flex",
-                    alignItems: "center",
-                    justifyContent: "center",
-                    width: "100%",
-                    padding: "0.5rem",
-                    borderRadius: "9999px",
-                    border: "none",
-                    background: "#ffc107",
-                    color: "#000",
-                    fontSize: "0.95rem",
-                    cursor: "pointer",
-                    margin: "0.5rem 0"
-                  },
-                  children: [
-                    /* @__PURE__ */ jsx(FaCheckSquare, { style: { marginRight: "0.5rem" } }),
-                    "Selecionar m\xFAltiplos"
-                  ]
-                }
-              ) : /* @__PURE__ */ jsxs("div", { style: { display: "flex", gap: "0.5rem", margin: "0.5rem 0" }, children: [
-                /* @__PURE__ */ jsxs(
-                  "button",
-                  {
-                    onClick: handleConfirm,
-                    style: {
-                      flex: 1,
-                      display: "flex",
-                      alignItems: "center",
-                      justifyContent: "center",
-                      padding: "0.5rem",
-                      borderRadius: "9999px",
-                      border: "none",
-                      background: "#28a745",
-                      color: "#fff",
-                      fontSize: "0.95rem",
-                      cursor: "pointer"
-                    },
-                    children: [
-                      /* @__PURE__ */ jsx(FaCheck, { style: { marginRight: "0.5rem" } }),
-                      "Confirmar sele\xE7\xE3o"
-                    ]
-                  }
-                ),
-                /* @__PURE__ */ jsxs(
-                  "button",
-                  {
-                    onClick: cancelMulti,
-                    style: {
-                      flex: 1,
-                      display: "flex",
-                      alignItems: "center",
-                      justifyContent: "center",
-                      padding: "0.5rem",
-                      borderRadius: "9999px",
-                      border: "none",
-                      background: "#6c757d",
-                      color: "#fff",
-                      fontSize: "0.95rem",
-                      cursor: "pointer"
-                    },
-                    children: [
-                      /* @__PURE__ */ jsx(MdClose, { style: { marginRight: "0.5rem" } }),
-                      "Cancelar"
-                    ]
-                  }
-                )
-              ] }),
-              /* @__PURE__ */ jsx("div", { style: { padding: "0.5rem" }, children: visibleNodes.map((bn) => {
-                const selected = multiMode ? multiSelected.some((r) => r.id === bn.recurso.id) : false;
-                return /* @__PURE__ */ jsxs(
-                  "div",
-                  {
-                    onClick: () => handleItemClick(bn),
-                    style: {
-                      display: "flex",
-                      justifyContent: "space-between",
-                      alignItems: "center",
-                      padding: "0.5rem",
-                      borderBottom: "1px solid #ddd",
-                      background: selected ? "#e9ecef" : "transparent",
-                      cursor: "pointer",
-                      transition: "background 0.1s"
-                    },
-                    onMouseEnter: (e) => {
-                      if (!selected) e.currentTarget.style.background = "#e2e6ea";
-                    },
-                    onMouseLeave: (e) => {
-                      e.currentTarget.style.background = selected ? "#e9ecef" : "transparent";
-                    },
-                    children: [
-                      /* @__PURE__ */ jsx("span", { children: bn.recurso.nome }),
-                      selected && /* @__PURE__ */ jsx(FaCheck, {})
-                    ]
-                  },
-                  bn.recurso.id
-                );
-              }) })
-            ]
+  }, [arvoreCtrl, branchLevelCtrl, dispatch]);
+  const advanceBranch = useCallback12(
+    async (bn) => {
+      var _a2, _b2, _c, _d;
+      setIsLoading(true);
+      try {
+        const current = branchesRef.current;
+        const parentBranch = current.find((b) => b.id === bn.branchId);
+        const currentLevel = (_b2 = (_a2 = parentBranch == null ? void 0 : parentBranch.branchLevel) == null ? void 0 : _a2.level) != null ? _b2 : 1;
+        const branchsToStay = current.filter((b) => {
+          var _a3, _b3;
+          return ((_b3 = (_a3 = b.branchLevel) == null ? void 0 : _a3.level) != null ? _b3 : 0) <= currentLevel;
+        }).map(
+          (b) => {
+            var _a3;
+            return ((_a3 = b.branchLevel) == null ? void 0 : _a3.level) === currentLevel ? { ...b, nomeRecurso: bn.recurso.nome } : b;
           }
-        )
-      ]
-    }
-  );
-};
-var BranchDropDisplay_default = BranchDropDisplay;
-
-// src/components/recurso/FindRecursoByTagField.tsx
-import { useState as useState11 } from "react";
-import { GrCheckmark } from "react-icons/gr";
-
-// src/components/recurso/AutoComplete.tsx
-import { useEffect as useEffect4, useState as useState8 } from "react";
-import { FloatingLabel, Form, InputGroup, ListGroup } from "react-bootstrap";
-import { Fragment, jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
-var AutoComplete = ({
-  className,
-  ops,
-  sortKey,
-  displayKey,
-  displayKeys,
-  onValueChanged,
-  selectedKey,
-  onSelectedClick,
-  value,
-  actionButton,
-  actionButton2,
-  placeH,
-  title,
-  filter,
-  filterField,
-  loadFunc,
-  loadCondition,
-  isBold,
-  onBlurEvent,
-  formatationFunc,
-  onEscKeyDown,
-  margT,
-  hideComponent,
-  disableComponent = false,
-  disableSelect = false,
-  margB,
-  autoFocusConfig,
-  onLoad,
-  onMouseLv,
-  useStandardLabel = false,
-  isRequired = false,
-  ty = "text"
-}) => {
-  const [liItem, setListItem] = useState8([]);
-  const [options, setOptions] = useState8([]);
-  const [input, setInput] = useState8("");
-  const [hide, setHide] = useState8(true);
-  const [onLoaded, setOnLoaded] = useState8(false);
-  const sortOptions = (opts, key) => {
-    if (!key || !Array.isArray(opts)) return opts != null ? opts : [];
-    return [...opts].sort((a, b) => String(a[key]).localeCompare(String(b[key])));
-  };
-  useEffect4(() => {
-    if (value) setInput(value);
-    else setInput("");
-  }, [value]);
-  useEffect4(() => {
-    const sortedOptions = sortOptions(ops, sortKey);
-    setListItem(sortedOptions);
-    setOptions(sortedOptions);
-  }, [ops, sortKey]);
-  useEffect4(() => {
-    const loadFunction = async () => {
-      if (loadCondition && loadFunc) {
-        try {
-          const res = await loadFunc();
-          let newOps = res.content ? res.content : res;
-          newOps = newOps.filter((c) => c != null);
-          if (Array.isArray(newOps)) {
-            if (filter) {
-              newOps = newOps.filter((op) => op[filterField] === filter);
+        );
+        const nextBranchId = (_d = bn.recurso.branchId) != null ? _d : (_c = bn.recurso.branch) == null ? void 0 : _c.id;
+        if (nextBranchId) {
+          try {
+            const nextBranch = await arvoreCtrl.read("branch", nextBranchId);
+            if (nextBranch && nextBranch.branchLevel) {
+              branchsToStay.push(nextBranch);
             }
-            const sortedOptions = sortOptions(newOps, sortKey);
-            setListItem(sortedOptions);
-            setOptions(sortedOptions);
+          } catch (e) {
+            console.warn(
+              "[RecursoDisplayerVM] Failed to fetch child branch:",
+              e
+            );
           }
-          if (onLoad) {
-            if (onLoaded) return;
-            setOnLoaded(true);
-            onLoad(newOps);
-          }
-        } catch (e) {
-          setListItem([]);
         }
+        setBranches([...branchsToStay]);
+      } finally {
+        setIsLoading(false);
       }
-    };
-    loadFunction();
-  }, [loadCondition, filter, filterField, sortKey, onLoad]);
-  const onFieldUpdate = (val) => {
-    let newListItem;
-    if (val && val.length > 0) {
-      const regex = new RegExp(`${val}`, "i");
-      newListItem = options.filter((liI) => {
-        let textToTest;
-        if (formatationFunc) {
-          textToTest = formatationFunc(liI);
-        } else if (displayKey) {
-          textToTest = liI[displayKey];
-        } else if (displayKeys) {
-          textToTest = keysJoinner(liI);
-        } else {
-          textToTest = liI;
+    },
+    [arvoreCtrl]
+  );
+  const backToBranch = useCallback12((branch) => {
+    setBranches(
+      (prev) => prev.filter(
+        (b) => {
+          var _a2, _b2, _c, _d;
+          return ((_b2 = (_a2 = b.branchLevel) == null ? void 0 : _a2.level) != null ? _b2 : 0) <= ((_d = (_c = branch.branchLevel) == null ? void 0 : _c.level) != null ? _d : 0);
         }
-        return regex.test(textToTest);
-      });
-      setListItem(newListItem);
-    } else {
-      setListItem(options);
+      )
+    );
+  }, []);
+  const reset = useCallback12(() => {
+    setBranches([]);
+  }, []);
+  return useMemo7(
+    () => ({
+      branches,
+      isLoading,
+      loadInitialBranches,
+      advanceBranch,
+      backToBranch,
+      reset
+    }),
+    [branches, isLoading, loadInitialBranches, advanceBranch, backToBranch, reset]
+  );
+}
+
+// src/viewmodels/ReduxFindRecursoByTagAdapter.ts
+import { useCallback as useCallback13, useMemo as useMemo8, useState as useState12 } from "react";
+function useFindRecursoByTagViewModel(overrides = {}) {
+  var _a;
+  const defaultRecurso = useHttpController("recurso");
+  const recursoCtrl = (_a = overrides.recursoController) != null ? _a : defaultRecurso;
+  const [isSearching, setIsSearching] = useState12(false);
+  const loadActiveTags = useCallback13(async () => {
+    try {
+      const res = await recursoCtrl.get("findActiveRecursosTags");
+      return Array.isArray(res) ? res : [];
+    } catch (err) {
+      console.warn("[FindRecursoByTagVM] loadActiveTags failed:", err);
+      return [];
     }
-    onValueChanged && onValueChanged(val);
-    setInput(val);
-    setHide(false);
-  };
-  const clear = () => {
-    setInput("");
-  };
-  const onOpSelected = (li, index, lItem) => {
-    if (formatationFunc) {
-      setInput(formatationFunc(li));
-    } else if (displayKey) {
-      setInput(li[displayKey]);
-    } else if (displayKeys) {
-      setInput(keysJoinner(li));
-    } else {
-      setInput(li);
+  }, [recursoCtrl]);
+  const searchByTagId = useCallback13(
+    async (tagId) => {
+      setIsSearching(true);
+      try {
+        const r = await recursoCtrl.read("findRecursoByTagId", tagId);
+        return r != null ? r : null;
+      } catch (err) {
+        console.error("[FindRecursoByTagVM] searchByTagId failed:", err);
+        return null;
+      } finally {
+        setIsSearching(false);
+      }
+    },
+    [recursoCtrl]
+  );
+  const searchByTag = useCallback13(
+    async (description) => {
+      setIsSearching(true);
+      try {
+        const formatted = description.replace(/\s/g, "");
+        const r = await recursoCtrl.read(
+          "recurso/findByTagDescription",
+          formatted
+        );
+        return r != null ? r : null;
+      } catch (err) {
+        console.error("[FindRecursoByTagVM] searchByTag failed:", err);
+        return null;
+      } finally {
+        setIsSearching(false);
+      }
+    },
+    [recursoCtrl]
+  );
+  return useMemo8(
+    () => ({
+      isSearching,
+      loadActiveTags,
+      searchByTagId,
+      searchByTag
+    }),
+    [isSearching, loadActiveTags, searchByTagId, searchByTag]
+  );
+}
+
+// src/viewmodels/ReduxJustificativaModalAdapter.ts
+import { useCallback as useCallback14, useEffect as useEffect4, useMemo as useMemo9, useRef as useRef3, useState as useState13 } from "react";
+function localId() {
+  return `local_${Date.now()}_${Math.random().toString(36).slice(2, 9)}`;
+}
+function runValidate3(draft) {
+  const errors = {};
+  if (!draft || !draft.trim()) {
+    errors.draft = "Descreva o motivo antes de adicionar.";
+  }
+  return { ok: Object.keys(errors).length === 0, errors };
+}
+function useJustificativaModalViewModel(opts) {
+  const { initialJustificativas = [], currentUser, onUpdate } = opts;
+  const [justificativas, setJustificativas] = useState13(
+    initialJustificativas
+  );
+  const [draft, setDraft] = useState13("");
+  const [editingId, setEditingId] = useState13(null);
+  const [isSubmitting, setIsSubmitting] = useState13(false);
+  const initialRef = useRef3(initialJustificativas);
+  useEffect4(() => {
+    initialRef.current = initialJustificativas;
+    setJustificativas(initialJustificativas);
+  }, [initialJustificativas]);
+  const commit = useCallback14(
+    async (next) => {
+      setJustificativas(next);
+      if (!onUpdate) return next;
+      try {
+        const maybe = await Promise.resolve(onUpdate(next));
+        if (Array.isArray(maybe)) {
+          setJustificativas(maybe);
+          return maybe;
+        }
+      } catch (e) {
+      }
+      return next;
+    },
+    [onUpdate]
+  );
+  const startEdit = useCallback14(
+    (id) => {
+      var _a;
+      const target = justificativas.find((j) => j.id === id);
+      if (!target || target.removed) return;
+      setEditingId(id);
+      setDraft((_a = target.descricao) != null ? _a : "");
+    },
+    [justificativas]
+  );
+  const cancelEdit = useCallback14(() => {
+    setEditingId(null);
+    setDraft("");
+  }, []);
+  const addOrEdit = useCallback14(async () => {
+    const result = runValidate3(draft);
+    if (!result.ok) return justificativas;
+    setIsSubmitting(true);
+    try {
+      let next;
+      if (editingId != null) {
+        next = justificativas.map(
+          (j) => j.id === editingId ? { ...j, descricao: draft } : j
+        );
+      } else {
+        const nova = {
+          id: localId(),
+          descricao: draft,
+          user: currentUser,
+          createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+          isNew: true
+        };
+        next = [...justificativas, nova];
+      }
+      const committed = await commit(next);
+      setDraft("");
+      setEditingId(null);
+      return committed;
+    } finally {
+      setIsSubmitting(false);
     }
-    onSelectedClick(li, index, lItem);
-    setHide(true);
-  };
-  const keysJoinner = (li) => {
-    if (!displayKeys || !Array.isArray(displayKeys)) return "";
-    const textToRender = displayKeys.map((key) => `${li[key]} `);
-    return textToRender.join("").trim();
-  };
-  const renderMoreThanOneKey = (li, index) => {
-    const buildedString = keysJoinner(li);
-    return /* @__PURE__ */ jsx2("li", { children: buildedString }, index);
-  };
-  const boldedPart = (text, key) => {
-    return /* @__PURE__ */ jsx2("li", { children: text }, key);
-  };
-  const displayListItens = (li, index) => {
-    if (formatationFunc) {
-      return boldedPart(formatationFunc(li), index);
+  }, [draft, editingId, justificativas, currentUser, commit]);
+  const remove = useCallback14(
+    async (id) => {
+      const next = justificativas.map(
+        (j) => j.id === id ? { ...j, removed: true } : j
+      );
+      return commit(next);
+    },
+    [justificativas, commit]
+  );
+  const undoRemove = useCallback14(
+    async (id) => {
+      const next = justificativas.map(
+        (j) => j.id === id ? { ...j, removed: false } : j
+      );
+      return commit(next);
+    },
+    [justificativas, commit]
+  );
+  const validate = useCallback14(
+    () => runValidate3(draft),
+    [draft]
+  );
+  const reset = useCallback14(() => {
+    setJustificativas(initialRef.current);
+    setDraft("");
+    setEditingId(null);
+  }, []);
+  const populateFromExisting = useCallback14((list) => {
+    initialRef.current = list;
+    setJustificativas(list);
+    setDraft("");
+    setEditingId(null);
+  }, []);
+  return useMemo9(
+    () => ({
+      justificativas,
+      draft,
+      editingId,
+      isSubmitting,
+      setDraft,
+      startEdit,
+      cancelEdit,
+      addOrEdit,
+      remove,
+      undoRemove,
+      validate,
+      reset,
+      populateFromExisting
+    }),
+    [
+      justificativas,
+      draft,
+      editingId,
+      isSubmitting,
+      startEdit,
+      cancelEdit,
+      addOrEdit,
+      remove,
+      undoRemove,
+      validate,
+      reset,
+      populateFromExisting
+    ]
+  );
+}
+
+// src/viewmodels/ReduxAnexoManagerAdapter.ts
+import { useMemo as useMemo10 } from "react";
+function useAnexoManagerViewModel(opts) {
+  const base = useAnexoManager(opts);
+  return useMemo10(
+    () => ({
+      persistidos: base.persistidos,
+      locais: base.locais,
+      loading: base.loading,
+      loadAnexos: base.loadAnexos,
+      addFiles: base.addFiles,
+      removeLocal: base.removeLocal,
+      uploadAll: base.uploadAll,
+      removePersistido: base.removePersistido,
+      getUrl: base.getUrl
+    }),
+    [
+      base.persistidos,
+      base.locais,
+      base.loading,
+      base.loadAnexos,
+      base.addFiles,
+      base.removeLocal,
+      base.uploadAll,
+      base.removePersistido,
+      base.getUrl
+    ]
+  );
+}
+
+// src/viewmodels/useRecorrenciaViewModel.ts
+import { useCallback as useCallback15, useMemo as useMemo11, useState as useState14 } from "react";
+import { useDispatch as useDispatch5, useSelector as useSelector5 } from "react-redux";
+
+// src/viewmodels/recorrenciaSlice.ts
+import { createSlice as createSlice4 } from "@reduxjs/toolkit";
+var DEFAULT_KEY3 = "__default__";
+var initialState4 = {
+  byEntity: {}
+};
+var keyOf3 = (entityId) => entityId === void 0 || entityId === null || entityId === "" ? DEFAULT_KEY3 : String(entityId);
+var ensureSlot = (state, key) => {
+  const existing = state.byEntity[key];
+  if (!existing) {
+    const fresh = {
+      valor: 1,
+      escala: "day",
+      dataInicio: void 0
+    };
+    state.byEntity[key] = fresh;
+    return fresh;
+  }
+  return existing;
+};
+var recorrenciaSlice = createSlice4({
+  name: "recorrenciaVm",
+  initialState: initialState4,
+  reducers: {
+    setValor(state, action) {
+      const key = keyOf3(action.payload.entityId);
+      ensureSlot(state, key).valor = action.payload.value;
+    },
+    setEscala(state, action) {
+      const key = keyOf3(action.payload.entityId);
+      ensureSlot(state, key).escala = action.payload.value;
+    },
+    setDataInicio(state, action) {
+      const key = keyOf3(action.payload.entityId);
+      const next = action.payload.value;
+      ensureSlot(state, key).dataInicio = next === null || next === void 0 || next === "" ? void 0 : next;
+    },
+    populate(state, action) {
+      const key = keyOf3(action.payload.entityId);
+      state.byEntity[key] = action.payload.value ? { ...action.payload.value } : null;
+    },
+    clearRecorrencia(state, action) {
+      var _a;
+      const key = keyOf3((_a = action.payload) == null ? void 0 : _a.entityId);
+      state.byEntity[key] = null;
     }
-    if (displayKey) {
-      return boldedPart(li[displayKey], index);
+  }
+});
+var {
+  setValor: setRecorrenciaValor,
+  setEscala: setRecorrenciaEscala,
+  setDataInicio: setRecorrenciaDataInicio,
+  populate: populateRecorrencia,
+  clearRecorrencia
+} = recorrenciaSlice.actions;
+var selectRecorrencia = (state, entityId) => {
+  var _a, _b;
+  const key = keyOf3(entityId);
+  const slice3 = (_a = state == null ? void 0 : state.recorrenciaVm) != null ? _a : state == null ? void 0 : state.recorrencia;
+  const slot = (_b = slice3 == null ? void 0 : slice3.byEntity) == null ? void 0 : _b[key];
+  return slot === void 0 ? null : slot;
+};
+var recorrenciaSlice_default = recorrenciaSlice.reducer;
+
+// src/viewmodels/useRecorrenciaViewModel.ts
+function runValidate4(value) {
+  const errors = {};
+  if (value === null) {
+    errors._absent = "Sem recorrencia definida.";
+    return { ok: false, errors };
+  }
+  const valor = Number(value.valor);
+  if (!Number.isFinite(valor) || valor < 1) {
+    errors.valor = "O valor da recorrencia deve ser >= 1.";
+  }
+  if (!value.escala) {
+    errors.escala = "A escala eh obrigatoria.";
+  }
+  return { ok: Object.keys(errors).length === 0, errors };
+}
+function useRecorrenciaViewModel(entityId) {
+  const dispatch = useDispatch5();
+  const value = useSelector5(
+    (state) => selectRecorrencia(state, entityId)
+  );
+  const [isSubmitting, setIsSubmitting] = useState14(false);
+  const onValorChange = useCallback15(
+    (valor) => {
+      dispatch(setRecorrenciaValor({ entityId, value: valor }));
+    },
+    [dispatch, entityId]
+  );
+  const onEscalaChange = useCallback15(
+    (escala) => {
+      dispatch(setRecorrenciaEscala({ entityId, value: escala }));
+    },
+    [dispatch, entityId]
+  );
+  const onDataInicioChange = useCallback15(
+    (dataInicio) => {
+      dispatch(setRecorrenciaDataInicio({ entityId, value: dataInicio }));
+    },
+    [dispatch, entityId]
+  );
+  const clear = useCallback15(() => {
+    dispatch(clearRecorrencia({ entityId }));
+  }, [dispatch, entityId]);
+  const populateFromExisting = useCallback15(
+    (next) => {
+      dispatch(populateRecorrencia({ entityId, value: next }));
+    },
+    [dispatch, entityId]
+  );
+  const validate = useCallback15(
+    () => runValidate4(value),
+    [value]
+  );
+  const submit = useCallback15(async () => {
+    var _a;
+    setIsSubmitting(true);
+    try {
+      if (value === null) return null;
+      const result = runValidate4(value);
+      if (!result.ok) {
+        const firstErr = (_a = Object.values(result.errors)[0]) != null ? _a : "Dados invalidos.";
+        throw new Error(firstErr);
+      }
+      return value;
+    } finally {
+      setIsSubmitting(false);
     }
-    if (displayKeys) {
-      return renderMoreThanOneKey(li, index);
+  }, [value]);
+  const isValid = useMemo11(() => runValidate4(value).ok, [value]);
+  return useMemo11(
+    () => ({
+      value,
+      isValid,
+      isSubmitting,
+      onValorChange,
+      onEscalaChange,
+      onDataInicioChange,
+      clear,
+      populateFromExisting,
+      validate,
+      submit,
+      reset: clear
+    }),
+    [
+      value,
+      isValid,
+      isSubmitting,
+      onValorChange,
+      onEscalaChange,
+      onDataInicioChange,
+      clear,
+      populateFromExisting,
+      validate,
+      submit
+    ]
+  );
+}
+
+// src/viewmodels/useContadorViewModel.ts
+import { useCallback as useCallback16, useMemo as useMemo12, useState as useState15 } from "react";
+import { useDispatch as useDispatch6, useSelector as useSelector6 } from "react-redux";
+
+// src/viewmodels/contadorSlice.ts
+import { createSlice as createSlice5 } from "@reduxjs/toolkit";
+var DEFAULT_KEY4 = "__default__";
+var emptyValue3 = {
+  valor: null,
+  unidade: null,
+  parametro: null,
+  limitesDeControle: []
+};
+var initialState5 = {
+  byEntity: {}
+};
+var keyOf4 = (entityId) => entityId === void 0 || entityId === null || entityId === "" ? DEFAULT_KEY4 : String(entityId);
+var ensure3 = (state, key) => {
+  if (!state.byEntity[key]) {
+    state.byEntity[key] = { ...emptyValue3, limitesDeControle: [] };
+  }
+  return state.byEntity[key];
+};
+var contadorSlice = createSlice5({
+  name: "contadorVm",
+  initialState: initialState5,
+  reducers: {
+    setValor(state, action) {
+      ensure3(state, keyOf4(action.payload.entityId)).valor = action.payload.value;
+    },
+    setUnidade(state, action) {
+      ensure3(state, keyOf4(action.payload.entityId)).unidade = action.payload.value;
+    },
+    setParametro(state, action) {
+      ensure3(state, keyOf4(action.payload.entityId)).parametro = action.payload.value;
+    },
+    addLimite(state, action) {
+      var _a;
+      const slot = ensure3(state, keyOf4(action.payload.entityId));
+      slot.limitesDeControle = [
+        ...(_a = slot.limitesDeControle) != null ? _a : [],
+        action.payload.value
+      ];
+    },
+    removeLimiteAt(state, action) {
+      var _a;
+      const slot = ensure3(state, keyOf4(action.payload.entityId));
+      const list = (_a = slot.limitesDeControle) != null ? _a : [];
+      slot.limitesDeControle = list.filter(
+        (_, i) => i !== action.payload.index
+      );
+    },
+    updateLimiteAt(state, action) {
+      var _a;
+      const slot = ensure3(state, keyOf4(action.payload.entityId));
+      const list = [...(_a = slot.limitesDeControle) != null ? _a : []];
+      if (action.payload.index >= 0 && action.payload.index < list.length) {
+        list[action.payload.index] = action.payload.value;
+        slot.limitesDeControle = list;
+      }
+    },
+    populate(state, action) {
+      var _a;
+      const key = keyOf4(action.payload.entityId);
+      const v = (_a = action.payload.value) != null ? _a : emptyValue3;
+      state.byEntity[key] = {
+        ...emptyValue3,
+        ...v,
+        limitesDeControle: Array.isArray(v.limitesDeControle) ? [...v.limitesDeControle] : []
+      };
+    },
+    clearContador(state, action) {
+      var _a;
+      const key = keyOf4((_a = action.payload) == null ? void 0 : _a.entityId);
+      state.byEntity[key] = { ...emptyValue3, limitesDeControle: [] };
     }
-    return boldedPart(li, index);
+  }
+});
+var {
+  setValor: setContadorValor,
+  setUnidade: setContadorUnidade,
+  setParametro: setContadorParametro,
+  addLimite: addContadorLimite,
+  removeLimiteAt: removeContadorLimiteAt,
+  updateLimiteAt: updateContadorLimiteAt,
+  populate: populateContador,
+  clearContador
+} = contadorSlice.actions;
+var selectContador = (state, entityId) => {
+  var _a, _b, _c;
+  const key = keyOf4(entityId);
+  const slice3 = (_a = state == null ? void 0 : state.contadorVm) != null ? _a : state == null ? void 0 : state.contador;
+  return (_c = (_b = slice3 == null ? void 0 : slice3.byEntity) == null ? void 0 : _b[key]) != null ? _c : {
+    ...emptyValue3,
+    limitesDeControle: []
   };
-  const onKeyDownHandler = (event) => {
-    if (event.key === "Escape") {
-      setHide(true);
-      onEscKeyDown && onEscKeyDown();
+};
+var contadorSlice_default = contadorSlice.reducer;
+
+// src/viewmodels/useContadorViewModel.ts
+function runValidate5(value) {
+  var _a;
+  const errors = {};
+  if ((value == null ? void 0 : value.valor) !== null && (value == null ? void 0 : value.valor) !== void 0) {
+    if (!Number.isFinite(Number(value.valor))) {
+      errors.valor = "O valor deve ser um n\xFAmero finito.";
     }
-  };
-  return /* @__PURE__ */ jsxs2(
-    "div",
-    {
-      className: `${className}`,
-      style: { marginTop: margT || 4, marginBottom: margB || 4, position: "relative" },
-      onBlur: (e) => {
-        setTimeout(() => {
-          if (onBlurEvent) onBlurEvent(e, input);
-          setHide(true);
-        }, 200);
-      },
-      onKeyDown: (event) => onKeyDownHandler(event),
-      onMouseLeave: () => {
-        setHide(true);
-      },
-      children: [
-        !hideComponent && /* @__PURE__ */ jsxs2(Fragment, { children: [
-          useStandardLabel && title && /* @__PURE__ */ jsxs2(Form.Label, { children: [
-            title,
-            isRequired && " *"
-          ] }),
-          /* @__PURE__ */ jsxs2(InputGroup, { children: [
-            useStandardLabel ? /* @__PURE__ */ jsx2(
-              Form.Control,
-              {
-                autoFocus: autoFocusConfig,
-                disabled: disableComponent || disableSelect,
-                placeholder: placeH,
-                autoComplete: "off",
-                value: input,
-                onClickCapture: () => {
-                  setHide(false);
-                  if (!input) {
-                    onFieldUpdate("");
-                  }
-                },
-                onChange: (event) => onFieldUpdate(event.currentTarget.value),
-                type: "text"
-              }
-            ) : /* @__PURE__ */ jsx2(FloatingLabel, { style: { zIndex: 0 }, label: title, controlId: "floatingInput", children: /* @__PURE__ */ jsx2(
-              Form.Control,
-              {
-                autoFocus: autoFocusConfig,
-                disabled: disableComponent || disableSelect,
-                placeholder: placeH,
-                autoComplete: "off",
-                value: input,
-                onClickCapture: () => {
-                  setHide(false);
-                  if (!input) {
-                    onFieldUpdate("");
-                  }
-                },
-                onChange: (event) => onFieldUpdate(event.currentTarget.value),
-                type: "text"
-              }
-            ) }),
-            !disableComponent && actionButton && actionButton(clear),
-            !disableComponent && actionButton2 && actionButton2(input)
-          ] })
-        ] }),
-        liItem && /* @__PURE__ */ jsx2(ListGroup, { className: "listgroup-autocomplete", hidden: hide, children: liItem.map((li, index) => /* @__PURE__ */ jsx2(ListGroup.Item, { action: true, onClick: () => onOpSelected(li, index, liItem), children: displayListItens(li, index) }, index)) })
-      ]
+  }
+  if ((value == null ? void 0 : value.valor) !== null && (value == null ? void 0 : value.valor) !== void 0 && (!value.unidade || String(value.unidade).trim() === "")) {
+    errors.unidade = "Informe a unidade de medida.";
+  }
+  const limites = (_a = value == null ? void 0 : value.limitesDeControle) != null ? _a : [];
+  limites.forEach((l, idx) => {
+    if (!(l == null ? void 0 : l.nome) || String(l.nome).trim() === "") {
+      errors[`limitesDeControle[${idx}].nome`] = "Nome do limite \xE9 obrigat\xF3rio.";
+    }
+    if (!(l == null ? void 0 : l.boundRule)) {
+      errors[`limitesDeControle[${idx}].boundRule`] = "Regra de compara\xE7\xE3o \xE9 obrigat\xF3ria.";
     }
+    const v = Number(l == null ? void 0 : l.valor);
+    if (!Number.isFinite(v)) {
+      errors[`limitesDeControle[${idx}].valor`] = "Valor do limite deve ser num\xE9rico.";
+    }
+  });
+  return { ok: Object.keys(errors).length === 0, errors };
+}
+function useContadorViewModel(entityId) {
+  const dispatch = useDispatch6();
+  const value = useSelector6(
+    (state) => selectContador(state, entityId)
   );
-};
-var AutoComplete_default = AutoComplete;
+  const [isSubmitting, setIsSubmitting] = useState15(false);
+  const onValorChange = useCallback16(
+    (v) => {
+      dispatch(setContadorValor({ entityId, value: v }));
+    },
+    [dispatch, entityId]
+  );
+  const onUnidadeChange = useCallback16(
+    (u) => {
+      dispatch(setContadorUnidade({ entityId, value: u }));
+    },
+    [dispatch, entityId]
+  );
+  const onParametroChange = useCallback16(
+    (p) => {
+      dispatch(setContadorParametro({ entityId, value: p }));
+    },
+    [dispatch, entityId]
+  );
+  const onLimiteAdd = useCallback16(
+    (limite) => {
+      dispatch(addContadorLimite({ entityId, value: limite }));
+    },
+    [dispatch, entityId]
+  );
+  const onLimiteRemove = useCallback16(
+    (index) => {
+      dispatch(removeContadorLimiteAt({ entityId, index }));
+    },
+    [dispatch, entityId]
+  );
+  const onLimiteUpdate = useCallback16(
+    (index, limite) => {
+      dispatch(updateContadorLimiteAt({ entityId, index, value: limite }));
+    },
+    [dispatch, entityId]
+  );
+  const validate = useCallback16(
+    () => runValidate5(value),
+    [value]
+  );
+  const reset = useCallback16(() => {
+    dispatch(clearContador({ entityId }));
+  }, [dispatch, entityId]);
+  const populateFromExisting = useCallback16(
+    (next) => {
+      dispatch(populateContador({ entityId, value: next }));
+    },
+    [dispatch, entityId]
+  );
+  const submit = useCallback16(async () => {
+    var _a;
+    setIsSubmitting(true);
+    try {
+      const result = runValidate5(value);
+      if (!result.ok) {
+        const firstErr = (_a = Object.values(result.errors)[0]) != null ? _a : "Dados inv\xE1lidos.";
+        throw new Error(firstErr);
+      }
+      return value;
+    } finally {
+      setIsSubmitting(false);
+    }
+  }, [value]);
+  const isValid = useMemo12(() => runValidate5(value).ok, [value]);
+  return useMemo12(
+    () => ({
+      value,
+      isValid,
+      isSubmitting,
+      onValorChange,
+      onUnidadeChange,
+      onParametroChange,
+      onLimiteAdd,
+      onLimiteRemove,
+      onLimiteUpdate,
+      validate,
+      submit,
+      reset,
+      populateFromExisting
+    }),
+    [
+      value,
+      isValid,
+      isSubmitting,
+      onValorChange,
+      onUnidadeChange,
+      onParametroChange,
+      onLimiteAdd,
+      onLimiteRemove,
+      onLimiteUpdate,
+      validate,
+      submit,
+      reset,
+      populateFromExisting
+    ]
+  );
+}
 
-// src/components/recurso/QrCodeScanButton.tsx
-import { useState as useState10 } from "react";
-import { BsQrCode } from "react-icons/bs";
+// src/viewmodels/useMantenedorPickerViewModel.ts
+import { useCallback as useCallback17, useEffect as useEffect5, useMemo as useMemo13 } from "react";
+import { useDispatch as useDispatch7, useSelector as useSelector7 } from "react-redux";
 
-// src/components/recurso/QrReader.tsx
-import QrScanner from "qr-scanner";
-import { useEffect as useEffect5, useRef as useRef3, useState as useState9 } from "react";
-import { jsx as jsx3, jsxs as jsxs3 } from "react/jsx-runtime";
-var QrReader = ({ callback }) => {
-  const scanner = useRef3(null);
-  const videoEl = useRef3(null);
-  const qrBoxEl = useRef3(null);
-  const [qrOn, setQrOn] = useState9(true);
-  const [scannedResult, setScannedResult] = useState9("");
-  const onScanSuccess = (result) => {
-    setScannedResult(result == null ? void 0 : result.data);
-    callback(result == null ? void 0 : result.data);
-  };
-  const onScanFail = (err) => {
-    console.error(err);
-  };
-  useEffect5(() => {
-    if ((videoEl == null ? void 0 : videoEl.current) && !scanner.current) {
-      scanner.current = new QrScanner(videoEl.current, onScanSuccess, {
-        onDecodeError: onScanFail,
-        preferredCamera: "environment",
-        highlightScanRegion: true,
-        highlightCodeOutline: true,
-        overlay: (qrBoxEl == null ? void 0 : qrBoxEl.current) || void 0
-      });
-      scanner.current.start().then(() => setQrOn(true)).catch((err) => {
-        if (err) setQrOn(false);
-      });
+// src/viewmodels/mantenedorPickerSlice.ts
+import { createSlice as createSlice6 } from "@reduxjs/toolkit";
+var initialState6 = { byEntity: {} };
+function ensureSlot2(state, key) {
+  if (!state.byEntity[key]) {
+    state.byEntity[key] = {
+      options: [],
+      searchTerm: "",
+      isLoading: false,
+      error: null,
+      pendingConfirm: null
+    };
+  }
+  return state.byEntity[key];
+}
+var slice = createSlice6({
+  name: "mantenedorPicker",
+  initialState: initialState6,
+  reducers: {
+    setOptions(state, action) {
+      ensureSlot2(state, action.payload.key).options = action.payload.options;
+    },
+    setSearchTerm(state, action) {
+      ensureSlot2(state, action.payload.key).searchTerm = action.payload.term;
+    },
+    setLoading(state, action) {
+      ensureSlot2(state, action.payload.key).isLoading = action.payload.loading;
+    },
+    setError(state, action) {
+      ensureSlot2(state, action.payload.key).error = action.payload.error;
+    },
+    setPendingConfirm(state, action) {
+      ensureSlot2(state, action.payload.key).pendingConfirm = action.payload.item;
+    },
+    clearSlot(state, action) {
+      delete state.byEntity[action.payload.key];
     }
-    return () => {
-      var _a;
-      if (!(videoEl == null ? void 0 : videoEl.current)) {
-        (_a = scanner == null ? void 0 : scanner.current) == null ? void 0 : _a.stop();
+  }
+});
+var {
+  setOptions: setMantenedorOptions,
+  setSearchTerm: setMantenedorSearchTerm,
+  setLoading: setMantenedorLoading,
+  setError: setMantenedorError,
+  setPendingConfirm: setMantenedorPendingConfirm,
+  clearSlot: clearMantenedorSlot
+} = slice.actions;
+var mantenedorPickerSlice_default = slice.reducer;
+
+// src/viewmodels/useMantenedorPickerViewModel.ts
+var DEFAULT_KEY5 = "__default__";
+function useMantenedorPickerViewModel(entityId) {
+  var _a, _b, _c, _d, _e;
+  const key = entityId != null && entityId !== "" ? String(entityId) : DEFAULT_KEY5;
+  const dispatch = useDispatch7();
+  const core = useCoreService();
+  const slot = useSelector7(
+    (s) => {
+      var _a2, _b2;
+      return (_b2 = (_a2 = s.mantenedorPicker) == null ? void 0 : _a2.byEntity[key]) != null ? _b2 : null;
+    }
+  );
+  const options = (_a = slot == null ? void 0 : slot.options) != null ? _a : [];
+  const searchTerm = (_b = slot == null ? void 0 : slot.searchTerm) != null ? _b : "";
+  const isLoading = (_c = slot == null ? void 0 : slot.isLoading) != null ? _c : false;
+  const error = (_d = slot == null ? void 0 : slot.error) != null ? _d : null;
+  const pendingConfirm = (_e = slot == null ? void 0 : slot.pendingConfirm) != null ? _e : null;
+  const refresh = useCallback17(async () => {
+    var _a2;
+    dispatch(setMantenedorLoading({ key, loading: true }));
+    dispatch(setMantenedorError({ key, error: null }));
+    try {
+      const controller = core.createController("mantenedor");
+      const raw = await controller.get("mantenedorDashboard");
+      const list = Array.isArray(raw) ? raw : Array.isArray(raw == null ? void 0 : raw.content) ? raw.content : Array.isArray(raw == null ? void 0 : raw.data) ? raw.data : Array.isArray(raw == null ? void 0 : raw.items) ? raw.items : [];
+      if (typeof window !== "undefined" && window.__DEV__ !== false) {
+        console.debug(
+          `[MantenedorPickerVM] refresh key="${key}" \u2192 ${list.length} options`,
+          { rawType: Array.isArray(raw) ? "array" : typeof raw }
+        );
       }
-    };
-  }, []);
-  useEffect5(() => {
-    if (!qrOn)
-      alert(
-        "Camera est\xE1 bloqueada ou inacess\xEDvel. Por Favor habilite a camera nas permiss\xF5es do seu navegador e recarregue a p\xE1gina."
+      dispatch(setMantenedorOptions({ key, options: list }));
+    } catch (e) {
+      if (typeof window !== "undefined" && window.__DEV__ !== false) {
+        console.error("[MantenedorPickerVM] refresh failed", e);
+      }
+      dispatch(
+        setMantenedorError({ key, error: (_a2 = e == null ? void 0 : e.message) != null ? _a2 : "fetch error" })
       );
-  }, [qrOn]);
-  return /* @__PURE__ */ jsxs3("div", { className: "qr-reader", children: [
-    /* @__PURE__ */ jsx3("video", { ref: videoEl }),
-    /* @__PURE__ */ jsx3("div", { ref: qrBoxEl, className: "qr-box" }),
-    scannedResult && /* @__PURE__ */ jsxs3(
-      "p",
-      {
-        style: {
-          position: "absolute",
-          top: 0,
-          left: 0,
-          zIndex: 99999,
-          color: "white"
-        },
-        children: [
-          "Scanned Result: ",
-          scannedResult
-        ]
+    } finally {
+      dispatch(setMantenedorLoading({ key, loading: false }));
+    }
+  }, [dispatch, key, core]);
+  useEffect5(() => {
+    refresh();
+  }, [key]);
+  const search = useCallback17(
+    (term) => {
+      dispatch(setMantenedorSearchTerm({ key, term }));
+    },
+    [dispatch, key]
+  );
+  const requestSelect = useCallback17(
+    (item, currentOsId) => {
+      if (item._busy && item.osId != null && item.osId !== currentOsId) {
+        dispatch(setMantenedorPendingConfirm({ key, item }));
+        return "confirm";
       }
-    )
-  ] });
-};
-var QrReader_default = QrReader;
+      return "immediate";
+    },
+    [dispatch, key]
+  );
+  const confirmSelect = useCallback17(() => {
+    const item = pendingConfirm;
+    dispatch(setMantenedorPendingConfirm({ key, item: null }));
+    return item;
+  }, [dispatch, key, pendingConfirm]);
+  const cancelConfirm = useCallback17(() => {
+    dispatch(setMantenedorPendingConfirm({ key, item: null }));
+  }, [dispatch, key]);
+  const reset = useCallback17(() => {
+    dispatch(clearMantenedorSlot({ key }));
+  }, [dispatch, key]);
+  const filteredOptions = useMemo13(() => {
+    const term = searchTerm.toLowerCase();
+    return [...options].filter(
+      (o) => {
+        var _a2;
+        return ((_a2 = o.nomeUsuario) != null ? _a2 : "").toLowerCase().includes(term);
+      }
+    ).sort(
+      (a, b) => {
+        var _a2, _b2;
+        return ((_a2 = a.nomeUsuario) != null ? _a2 : "").toLowerCase().localeCompare(((_b2 = b.nomeUsuario) != null ? _b2 : "").toLowerCase());
+      }
+    );
+  }, [options, searchTerm]);
+  return useMemo13(
+    () => ({
+      options,
+      filteredOptions,
+      searchTerm,
+      isLoading,
+      error,
+      pendingConfirm,
+      search,
+      refresh,
+      requestSelect,
+      confirmSelect,
+      cancelConfirm,
+      reset
+    }),
+    [
+      options,
+      filteredOptions,
+      searchTerm,
+      isLoading,
+      error,
+      pendingConfirm,
+      search,
+      refresh,
+      requestSelect,
+      confirmSelect,
+      cancelConfirm,
+      reset
+    ]
+  );
+}
 
-// src/components/recurso/QrCodeScanButton.tsx
-import { jsx as jsx4, jsxs as jsxs4 } from "react/jsx-runtime";
-var QrCodeScanButton = ({ callback }) => {
-  const [showQr, setShowQr] = useState10(false);
-  const qrShowHandler = () => {
-    setShowQr((prev) => !prev);
-  };
-  return /* @__PURE__ */ jsxs4(
-    "div",
-    {
-      className: "hoverable-div",
-      style: {
-        border: "solid",
-        borderTopRightRadius: "3px",
-        borderBottomRightRadius: "3px",
-        padding: "8px",
-        borderLeft: "none",
-        borderColor: "#ccc",
-        borderWidth: "1px"
-      },
-      children: [
-        showQr && /* @__PURE__ */ jsx4(
-          QrReader_default,
-          {
-            callback: (v) => {
-              qrShowHandler();
-              callback(v);
-            }
-          }
-        ),
-        /* @__PURE__ */ jsx4(
-          BsQrCode,
-          {
-            size: 25,
-            onClick: () => {
-              qrShowHandler();
-            }
-          }
-        )
-      ]
+// src/viewmodels/ReduxTarefaStatusAdapter.ts
+import { useCallback as useCallback18, useMemo as useMemo14, useState as useState16 } from "react";
+function useTarefaStatusViewModel(opts) {
+  const { tarefaId, fatherId, initialStatus = "PENDENTE" } = opts;
+  const { createController } = useCoreService();
+  const toast = useToast();
+  const [current, setCurrent] = useState16(initialStatus);
+  const [saving, setSaving] = useState16(false);
+  const tarefaCtrl = useMemo14(
+    () => createController("tarefa"),
+    [createController]
+  );
+  const toggle = useCallback18(async () => {
+    if (saving) return;
+    const previous = current;
+    const next = previous === "ENCERRADO" ? "PENDENTE" : "ENCERRADO";
+    setCurrent(next);
+    setSaving(true);
+    try {
+      const body = {
+        status: next
+      };
+      if (fatherId !== void 0 && fatherId !== null) {
+        body.fatherId = fatherId;
+      }
+      await tarefaCtrl.put(String(tarefaId), body);
+    } catch (err) {
+      setCurrent(previous);
+      const msg = (err == null ? void 0 : err.message) || "Nao foi possivel atualizar o status da tarefa.";
+      try {
+        toast.warning(msg);
+      } catch (e) {
+      }
+    } finally {
+      setSaving(false);
     }
+  }, [saving, current, tarefaCtrl, tarefaId, fatherId, toast]);
+  return useMemo14(
+    () => ({ current, toggle, saving }),
+    [current, toggle, saving]
   );
-};
-var QrCodeScanButton_default = QrCodeScanButton;
+}
 
-// src/components/recurso/FindRecursoByTagField.tsx
-import { jsx as jsx5 } from "react/jsx-runtime";
-var FindRecursoByTagField = ({ callback }) => {
-  const recursoController = useHttpController("recurso");
-  const [selectedTag, setSelectedTag] = useState11(null);
-  const [reachedRecurso, setReachedRecurso] = useState11(null);
-  const findRecursoByTagIdHandler = async (tagId) => {
-    const r = await recursoController.read("findRecursoByTagId", tagId);
-    setReachedRecurso(r);
-  };
-  const findRecursoByTagDescriptionHandler = async (description) => {
-    const recurso = await recursoController.read(
-      "recurso/findByTagDescription",
-      description.replace(" ", "")
-    );
-    if (!callback) {
-      console.log(recurso);
-    } else {
-      callback(recurso, true);
-    }
-  };
-  const confirmRecursoSelectionButton = () => /* @__PURE__ */ jsx5(
-    "div",
-    {
-      className: "hoverable-div",
-      style: {
-        border: "solid",
-        borderTopRightRadius: "3px",
-        borderBottomRightRadius: "3px",
-        padding: "8px",
-        borderLeft: "none",
-        borderColor: "#ccc",
-        borderWidth: "1px"
-      },
-      children: /* @__PURE__ */ jsx5(GrCheckmark, { size: 25, onClick: () => callback(reachedRecurso, true) })
-    }
+// src/viewmodels/ReduxObservacoesTarefaAdapter.ts
+import { useCallback as useCallback19, useMemo as useMemo15, useState as useState17 } from "react";
+function useObservacoesTarefaViewModel(opts) {
+  const { tarefaId } = opts;
+  const { createController } = useCoreService();
+  const toast = useToast();
+  const [list, setList] = useState17([]);
+  const [loading, setLoading] = useState17(false);
+  const tarefaCtrl = useMemo15(
+    () => createController("tarefa"),
+    [createController]
   );
-  return /* @__PURE__ */ jsx5("div", { children: /* @__PURE__ */ jsx5(
-    AutoComplete_default,
-    {
-      sortKey: "id",
-      loadCondition: true,
-      loadFunc: () => recursoController.get("findActiveRecursosTags"),
-      displayKey: "descricao",
-      title: "Selecione ou Digite a TAG",
-      isBold: true,
-      actionButton: confirmRecursoSelectionButton,
-      actionButton2: () => /* @__PURE__ */ jsx5(
-        QrCodeScanButton_default,
-        {
-          callback: (description) => findRecursoByTagDescriptionHandler(description)
-        }
-      ),
-      onSelectedClick: (v) => {
-        setSelectedTag(v);
-        findRecursoByTagIdHandler(v.id);
-      },
-      value: selectedTag == null ? void 0 : selectedTag.descricao
+  const load = useCallback19(async () => {
+    var _a;
+    setLoading(true);
+    try {
+      const res = await tarefaCtrl.get(
+        `readObservacoesTarefa/${tarefaId}`
+      );
+      setList(Array.isArray(res) ? res : (_a = res == null ? void 0 : res.data) != null ? _a : []);
+    } catch (err) {
+      setList([]);
+      const msg = (err == null ? void 0 : err.message) || "Nao foi possivel carregar as observacoes.";
+      try {
+        toast.warning(msg);
+      } catch (e) {
+      }
+    } finally {
+      setLoading(false);
     }
-  ) });
+  }, [tarefaCtrl, tarefaId, toast]);
+  const add = useCallback19(
+    async (obs) => {
+      setLoading(true);
+      try {
+        await tarefaCtrl.post(
+          `addObservacaoTarefa/${tarefaId}`,
+          obs
+        );
+        await load();
+      } catch (err) {
+        const msg = (err == null ? void 0 : err.message) || "Nao foi possivel adicionar a observacao.";
+        try {
+          toast.warning(msg);
+        } catch (e) {
+        }
+      } finally {
+        setLoading(false);
+      }
+    },
+    [tarefaCtrl, tarefaId, load, toast]
+  );
+  return useMemo15(
+    () => ({ list, loading, load, add }),
+    [list, loading, load, add]
+  );
+}
+
+// src/viewmodels/usePickMantenedorTipoViewModel.ts
+import { useCallback as useCallback20, useMemo as useMemo16 } from "react";
+import { useDispatch as useDispatch8, useSelector as useSelector8 } from "react-redux";
+
+// src/viewmodels/pickMantenedorTipoSlice.ts
+import { createSlice as createSlice7 } from "@reduxjs/toolkit";
+var initialState7 = {
+  mantenedores: [],
+  tiposDeOrdem: [],
+  loading: false,
+  assigning: false,
+  error: null
 };
-var FindRecursoByTagField_default = FindRecursoByTagField;
+var slice2 = createSlice7({
+  name: "pickMantenedorTipo",
+  initialState: initialState7,
+  reducers: {
+    setOptions(state, action) {
+      state.mantenedores = action.payload.mantenedores;
+      state.tiposDeOrdem = action.payload.tiposDeOrdem;
+    },
+    setLoading(state, action) {
+      state.loading = action.payload;
+    },
+    setAssigning(state, action) {
+      state.assigning = action.payload;
+    },
+    setError(state, action) {
+      state.error = action.payload;
+    },
+    reset() {
+      return initialState7;
+    }
+  }
+});
+var {
+  setOptions: setPickMantenedorTipoOptions,
+  setLoading: setPickMantenedorTipoLoading,
+  setAssigning: setPickMantenedorTipoAssigning,
+  setError: setPickMantenedorTipoError,
+  reset: resetPickMantenedorTipo
+} = slice2.actions;
+var pickMantenedorTipoSlice_default = slice2.reducer;
 
-// src/components/recurso/RecursoDisplayer.tsx
-import { jsx as jsx6, jsxs as jsxs5 } from "react/jsx-runtime";
-var RecursoDisplayer = ({
-  selectedList = [],
-  onSaveRecurso,
-  singleReturn = false
-}) => {
-  const arvoreEstruturalController = useHttpController("");
-  const branchLevelController = useHttpController("branchLevel");
-  const [branches, setBranches] = useState12([]);
-  const dispatch = useDispatch2();
-  const [localSelected, setLocalSelected] = useState12(selectedList);
-  const [selectorDisplay, setSelectorDisplay] = useState12("");
-  const [multiMode, setMultiMode] = useState12(false);
-  useEffect6(() => {
-    const init = async () => {
-      const b = await arvoreEstruturalController.get("branchByBranchLevel/1");
-      setBranches(b);
-      const lv = await branchLevelController.readAll();
-      dispatch(setLevels(lv));
-    };
-    init();
-  }, []);
-  const branchSetter = async (bn) => {
-    const copy = [...branches];
-    const branch = await arvoreEstruturalController.read("branch", bn.recurso.branch.id);
-    copy[bn.recurso.branch.branchLevel.level - 1] = {
-      ...branch,
-      nomeRecurso: bn.recurso.nome
-    };
-    setBranches(copy);
-  };
-  const backOnBranch = (branch) => {
-    const branchsToStay = branches.filter(
-      (bArray) => bArray.branchLevel.level <= branch.branchLevel.level
-    );
-    setBranches(branchsToStay);
-  };
-  return /* @__PURE__ */ jsxs5("div", { style: { width: "100%", padding: 0 }, children: [
-    /* @__PURE__ */ jsx6("div", { className: "d-flex justify-content-between align-items-center mb-3", children: /* @__PURE__ */ jsxs5("div", { children: [
-      /* @__PURE__ */ jsx6("label", { className: "me-2", children: "Selecionar Recurso Por:" }),
-      /* @__PURE__ */ jsx6(
-        Button,
-        {
-          size: "sm",
-          onClick: () => setSelectorDisplay("branch"),
-          variant: selectorDisplay === "branch" ? "primary" : "outline-primary",
-          className: "me-1",
-          children: "\xC1rvore"
+// src/viewmodels/usePickMantenedorTipoViewModel.ts
+var unwrapList = (raw) => {
+  if (Array.isArray(raw)) return raw;
+  const r = raw;
+  if (Array.isArray(r == null ? void 0 : r.content)) return r.content;
+  if (Array.isArray(r == null ? void 0 : r.data)) return r.data;
+  if (Array.isArray(r == null ? void 0 : r.items)) return r.items;
+  return [];
+};
+function usePickMantenedorTipoViewModel() {
+  var _a, _b, _c, _d, _e;
+  const dispatch = useDispatch8();
+  const core = useCoreService();
+  const state = useSelector8(
+    (s) => s.pickMantenedorTipo
+  );
+  const mantenedores = (_a = state == null ? void 0 : state.mantenedores) != null ? _a : [];
+  const tiposDeOrdem = (_b = state == null ? void 0 : state.tiposDeOrdem) != null ? _b : [];
+  const loading = (_c = state == null ? void 0 : state.loading) != null ? _c : false;
+  const assigning = (_d = state == null ? void 0 : state.assigning) != null ? _d : false;
+  const error = (_e = state == null ? void 0 : state.error) != null ? _e : null;
+  const loadOptions = useCallback20(async () => {
+    dispatch(setPickMantenedorTipoLoading(true));
+    dispatch(setPickMantenedorTipoError(null));
+    try {
+      const mantenedorCtl = core.createController("mantenedor");
+      const tipoCtl = core.createController("tipoDeOrdem");
+      const [mRaw, tRaw] = await Promise.all([
+        mantenedorCtl.get("mantenedorDashboard"),
+        tipoCtl.readAll()
+      ]);
+      const mantenedoresList = unwrapList(mRaw);
+      const tiposList = unwrapList(tRaw);
+      dispatch(
+        setPickMantenedorTipoOptions({
+          mantenedores: mantenedoresList,
+          tiposDeOrdem: tiposList
+        })
+      );
+    } catch (e) {
+      const msg = e instanceof Error ? e.message : "fetch error";
+      dispatch(setPickMantenedorTipoError(msg));
+    } finally {
+      dispatch(setPickMantenedorTipoLoading(false));
+    }
+  }, [dispatch, core]);
+  const assignMantenedores = useCallback20(
+    async (osId, items) => {
+      if (!items || items.length === 0) return;
+      dispatch(setPickMantenedorTipoAssigning(true));
+      try {
+        const ctl = core.createController("ordemDeServico");
+        for (const m of items) {
+          await ctl.post(`atribuirMantenedor/${osId}`, {
+            mantenedorId: m.id,
+            id: null,
+            userId: m.userId
+          });
         }
-      ),
-      /* @__PURE__ */ jsx6(
-        Button,
-        {
-          size: "sm",
-          onClick: () => setSelectorDisplay("TAG"),
-          variant: selectorDisplay === "TAG" ? "primary" : "outline-primary",
-          children: "TAG"
+      } finally {
+        dispatch(setPickMantenedorTipoAssigning(false));
+      }
+    },
+    [dispatch, core]
+  );
+  const assignTipo = useCallback20(
+    async (osId, tipoId) => {
+      dispatch(setPickMantenedorTipoAssigning(true));
+      try {
+        const ctl = core.createController("ordemDeServico");
+        await ctl.put(`updateTipoDeOrdem/${osId}`, { tipoOs: tipoId });
+      } finally {
+        dispatch(setPickMantenedorTipoAssigning(false));
+      }
+    },
+    [dispatch, core]
+  );
+  const assignMantenedoresMultiOs = useCallback20(
+    async (osIds, items) => {
+      if (!osIds.length || !items.length) return;
+      dispatch(setPickMantenedorTipoAssigning(true));
+      try {
+        const ctl = core.createController("ordemDeServico");
+        for (const m of items) {
+          await ctl.post("atribuirMantenedorBulk", {
+            osIds,
+            mantenedorId: m.id,
+            userId: m.userId
+          });
         }
-      )
-    ] }) }),
-    selectorDisplay === "branch" && branches.map((branch, i) => /* @__PURE__ */ jsx6(
-      BranchDropDisplay_default,
-      {
-        branch,
-        addBranch: branchSetter,
-        multiMode,
-        setMultiMode,
-        onSaveRecurso,
-        backOnBranch,
-        branches,
-        singleReturn
-      },
-      branch.id || i
-    )),
-    selectorDisplay === "TAG" && /* @__PURE__ */ jsx6(
-      FindRecursoByTagField_default,
-      {
-        callback: (rec, checked) => {
-          setLocalSelected([rec]);
-          onSaveRecurso([rec], checked);
+      } finally {
+        dispatch(setPickMantenedorTipoAssigning(false));
+      }
+    },
+    [dispatch, core]
+  );
+  const assignTipoMultiOs = useCallback20(
+    async (osIds, tipoId) => {
+      if (!osIds.length) return;
+      dispatch(setPickMantenedorTipoAssigning(true));
+      try {
+        const ctl = core.createController("ordemDeServico");
+        await ctl.post("updateTipoBulk", { osIds, tipoId });
+      } finally {
+        dispatch(setPickMantenedorTipoAssigning(false));
+      }
+    },
+    [dispatch, core]
+  );
+  const reset = useCallback20(() => {
+    dispatch(resetPickMantenedorTipo());
+  }, [dispatch]);
+  return useMemo16(
+    () => ({
+      mantenedores,
+      tiposDeOrdem,
+      loading,
+      assigning,
+      error,
+      loadOptions,
+      assignMantenedores,
+      assignTipo,
+      assignMantenedoresMultiOs,
+      assignTipoMultiOs,
+      reset
+    }),
+    [mantenedores, tiposDeOrdem, loading, assigning, error, loadOptions, assignMantenedores, assignTipo, assignMantenedoresMultiOs, assignTipoMultiOs, reset]
+  );
+}
+
+// src/viewmodels/ReduxTarefaItemAdapter.ts
+import { useCallback as useCallback21, useMemo as useMemo17, useRef as useRef4 } from "react";
+function useTarefaItemViewModel(opts) {
+  const { tarefaId, mode, fatherId, initialStatus } = opts;
+  const { createController, subscribe, unsubscribe } = useCoreService();
+  const toast = useToast();
+  const tarefaCtrl = useMemo17(
+    () => createController("tarefa"),
+    [createController]
+  );
+  const status = useTarefaStatusViewModel({ tarefaId, fatherId, initialStatus });
+  const observacoes = useObservacoesTarefaViewModel({ tarefaId });
+  const inspecao = useInspecaoModalViewModel(tarefaId);
+  const unidadeMaterial = useUnidadeMaterialViewModel(tarefaId);
+  const anexos = useAnexoManagerViewModel({
+    context: "tarefa",
+    entityId: tarefaId
+  });
+  const observacoesRef = useRef4(observacoes);
+  observacoesRef.current = observacoes;
+  const anexosRef = useRef4(anexos);
+  anexosRef.current = anexos;
+  const updateDescricao = useCallback21(
+    async (texto) => {
+      try {
+        await tarefaCtrl.put(String(tarefaId), { descricao: texto });
+      } catch (err) {
+        const msg = (err == null ? void 0 : err.message) || "Nao foi possivel atualizar a descricao da tarefa.";
+        try {
+          toast.warning(msg);
+        } catch (e) {
         }
+        throw err;
       }
-    )
-  ] });
-};
-var RecursoDisplayer_default = RecursoDisplayer;
+    },
+    [tarefaCtrl, tarefaId, toast]
+  );
+  const subscribeLive = useCallback21(() => {
+    if (mode !== "execute") {
+      return () => {
+      };
+    }
+    const refresher = () => {
+    };
+    const moTarefa = {
+      context: `tarefa${tarefaId}`,
+      location: "*",
+      refresher
+    };
+    const moTarefaJus = {
+      context: `tarefaJus${tarefaId}`,
+      location: "*",
+      refresher
+    };
+    subscribe(moTarefa);
+    subscribe(moTarefaJus);
+    return () => {
+      unsubscribe(moTarefa);
+      unsubscribe(moTarefaJus);
+    };
+  }, [mode, tarefaId, subscribe, unsubscribe]);
+  return useMemo17(
+    () => ({
+      status,
+      observacoes,
+      inspecao,
+      unidadeMaterial,
+      anexos,
+      updateDescricao,
+      subscribeLive
+    }),
+    [
+      status,
+      observacoes,
+      inspecao,
+      unidadeMaterial,
+      anexos,
+      updateDescricao,
+      subscribeLive
+    ]
+  );
+}
 
 // src/reducers/pickerReducer.ts
-import { createSlice as createSlice2 } from "@reduxjs/toolkit";
-var initialState2 = {
+import { createSlice as createSlice8 } from "@reduxjs/toolkit";
+var initialState8 = {
   selected: null,
   items: [],
   visible: false,
   context: ""
 };
-var pickerSlice = createSlice2({
+var pickerSlice = createSlice8({
   name: "picker",
-  initialState: initialState2,
+  initialState: initialState8,
   reducers: {
     setPickerSelected(state, action) {
       state.selected = action.payload;
@@ -1467,7 +2725,7 @@ var pickerSlice = createSlice2({
       state.context = action.payload;
     },
     clearPicker() {
-      return initialState2;
+      return initialState8;
     }
   }
 });
@@ -1480,6 +2738,20 @@ var {
 } = pickerSlice.actions;
 var pickerReducer_default = pickerSlice.reducer;
 
+// src/utils/colorUtils.ts
+function pickTextColorBasedOnBgColorAdvanced(bgColor, lightColor, darkColor) {
+  const color = bgColor.charAt(0) === "#" ? bgColor.substring(1, 7) : bgColor;
+  const r = parseInt(color.substring(0, 2), 16);
+  const g = parseInt(color.substring(2, 4), 16);
+  const b = parseInt(color.substring(4, 6), 16);
+  const uicolors = [r / 255, g / 255, b / 255];
+  const c = uicolors.map(
+    (col) => col <= 0.03928 ? col / 12.92 : Math.pow((col + 0.055) / 1.055, 2.4)
+  );
+  const L = 0.2126 * c[0] + 0.7152 * c[1] + 0.0722 * c[2];
+  return L > 0.179 ? darkColor : lightColor;
+}
+
 // src/utils/webVitals.ts
 function initWebVitals(observability) {
   if (typeof PerformanceObserver === "undefined") return;
@@ -1514,28 +2786,28 @@ function initWebVitals(observability) {
 }
 
 // src/utils/dateUtils.ts
-import dayjs from "dayjs";
+import dayjs2 from "dayjs";
 function formatDate(date, format = "DD/MM/YYYY") {
   if (!date) return "";
-  return dayjs(date).format(format);
+  return dayjs2(date).format(format);
 }
 function formatDateTime(date) {
   return formatDate(date, "DD/MM/YYYY HH:mm");
 }
 function isDateBefore(date1, date2) {
-  return dayjs(date1).isBefore(dayjs(date2));
+  return dayjs2(date1).isBefore(dayjs2(date2));
 }
 function isDateAfter(date1, date2) {
-  return dayjs(date1).isAfter(dayjs(date2));
+  return dayjs2(date1).isAfter(dayjs2(date2));
 }
 function daysBetween(start, end) {
-  return dayjs(end).diff(dayjs(start), "day");
+  return dayjs2(end).diff(dayjs2(start), "day");
 }
 function addDays(date, days) {
-  return dayjs(date).add(days, "day").toDate();
+  return dayjs2(date).add(days, "day").toDate();
 }
 function toISOString(date) {
-  return dayjs(date).toISOString();
+  return dayjs2(date).toISOString();
 }
 
 // src/utils/stringUtils.ts
@@ -1557,62 +2829,134 @@ function isBlank(str) {
   return !str || str.trim().length === 0;
 }
 export {
+  DEFAULT_KEY4 as CONTADOR_DEFAULT_KEY,
   CoreServiceBuilder,
   CoreServiceContext,
   DevAutoLogin,
+  FILTER_COMBINE_MODES,
   FederatedBridge,
   FetchHttpAdapter,
+  DEFAULT_KEY2 as INSPECAO_MODAL_DEFAULT_KEY,
   NullCoreService,
   NullHttpController,
   NullObservabilityAdapter,
   NullToastService,
-  RecursoDisplayer_default as RecursoDisplayer,
+  DEFAULT_KEY3 as RECORRENCIA_DEFAULT_KEY,
   StandaloneProvider,
   TracingHttpAdapter,
+  DEFAULT_KEY as UNIDADE_MATERIAL_DEFAULT_KEY,
+  addContadorLimite,
   addDays,
   branchLevelReducer_default as branchLevelReducer,
   buildTraceparent,
   capitalize,
   clearBranchLevelForm,
+  clearContador,
+  clearInspecaoModal,
+  clearMantenedorSlot,
   clearPicker,
+  clearRecorrencia,
+  clearUnidadeMaterial,
+  contadorSlice_default as contadorReducer,
   createReducersBundle,
+  createReducersFromManifest,
   daysBetween,
   formatDate,
   formatDateTime,
   generateSpanId,
   generateTraceId,
+  groupMenuSections,
+  hmsToSeconds,
   initWebVitals,
+  inspecaoModalSlice_default as inspecaoModalReducer,
   isBlank,
   isDateAfter,
   isDateBefore,
+  isHostedByCore,
+  mantenedorPickerSlice_default as mantenedorPickerReducer,
+  pickMantenedorTipoSlice_default as pickMantenedorTipoReducer,
   pickTextColorBasedOnBgColorAdvanced,
   pickerReducer_default as pickerReducer,
+  populateContador,
+  populateInspecaoModal,
+  populateRecorrencia,
   populateToEdit,
+  populateUnidadeMaterial,
+  recorrenciaSlice_default as recorrenciaReducer,
   removeAccents,
+  removeContadorLimiteAt,
+  removeInspecaoLimiteAt,
+  resetPickMantenedorTipo,
+  secondsToHms,
+  selectContador,
+  selectInspecaoModal,
+  selectRecorrencia,
+  selectUnidadeMaterial,
   setColor,
+  setContadorParametro,
+  setContadorUnidade,
+  setContadorValor,
   setExcludeLevels,
   setHaveComponente,
+  setInspecaoLimites,
+  setInspecaoNomeParametro,
+  setInspecaoParametro,
+  setInspecaoTipo,
+  setInspecaoUnidadeParametro,
   setLevel,
   setLevels,
+  setMantenedorError,
+  setMantenedorLoading,
+  setMantenedorOptions,
+  setMantenedorPendingConfirm,
+  setMantenedorSearchTerm,
   setNome,
+  setPickMantenedorTipoAssigning,
+  setPickMantenedorTipoError,
+  setPickMantenedorTipoLoading,
+  setPickMantenedorTipoOptions,
   setPickerContext,
   setPickerItems,
   setPickerSelected,
   setPickerVisible,
+  setRecorrenciaDataInicio,
+  setRecorrenciaEscala,
+  setRecorrenciaValor,
+  setMaterial as setUnidadeMaterialMaterial,
+  setQuantidade as setUnidadeMaterialQuantidade,
+  setUnidade as setUnidadeMaterialUnidade,
   slugify,
   toISOString,
   truncate,
+  unidadeMaterialSlice_default as unidadeMaterialReducer,
+  updateContadorLimiteAt,
+  useAnexoManager,
+  useAnexoManagerViewModel,
   useAnexoUpload,
+  useContadorViewModel,
   useCoreService,
   useFetchData,
+  useFilterCombineMode,
+  useFindRecursoByTagViewModel,
   useFormStorage,
   useHttpController,
+  useInspecaoModalViewModel,
+  useJustificativaModalViewModel,
+  useMantenedorPickerViewModel,
   useMatchingObject,
   useNavigator,
   useNotifications,
   useObservability,
+  useObservacoesTarefaViewModel,
+  usePickMantenedorTipoViewModel,
   usePostData,
+  useRecorrenciaViewModel,
+  useRecursoDisplayerViewModel,
   useSmartSearch,
+  useTarefaItemViewModel,
+  useTarefaStatusViewModel,
+  useTimeFormat,
   useToast,
+  useUnidadeMaterialViewModel,
   useValidation
 };