teraprox-core-sdk 0.3.10 → 0.3.14

package/dist/index.js

@@ -30,63 +30,135 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  CONTADOR_DEFAULT_KEY: () => DEFAULT_KEY4,
   CoreServiceBuilder: () => CoreServiceBuilder,
   CoreServiceContext: () => CoreServiceContext,
   DevAutoLogin: () => DevAutoLogin,
+  FILTER_COMBINE_MODES: () => FILTER_COMBINE_MODES,
   FederatedBridge: () => FederatedBridge,
   FetchHttpAdapter: () => FetchHttpAdapter,
+  INSPECAO_MODAL_DEFAULT_KEY: () => DEFAULT_KEY2,
   NullCoreService: () => NullCoreService,
   NullHttpController: () => NullHttpController,
   NullObservabilityAdapter: () => NullObservabilityAdapter,
   NullToastService: () => NullToastService,
-  RecursoDisplayer: () => RecursoDisplayer_default,
+  RECORRENCIA_DEFAULT_KEY: () => DEFAULT_KEY3,
   StandaloneProvider: () => StandaloneProvider,
   TracingHttpAdapter: () => TracingHttpAdapter,
+  UNIDADE_MATERIAL_DEFAULT_KEY: () => DEFAULT_KEY,
+  addContadorLimite: () => addContadorLimite,
   addDays: () => addDays,
   branchLevelReducer: () => branchLevelReducer_default,
   buildTraceparent: () => buildTraceparent,
   capitalize: () => capitalize,
   clearBranchLevelForm: () => clearBranchLevelForm,
+  clearContador: () => clearContador,
+  clearInspecaoModal: () => clearInspecaoModal,
+  clearMantenedorSlot: () => clearMantenedorSlot,
   clearPicker: () => clearPicker,
+  clearRecorrencia: () => clearRecorrencia,
+  clearUnidadeMaterial: () => clearUnidadeMaterial,
+  contadorReducer: () => contadorSlice_default,
   createReducersBundle: () => createReducersBundle,
+  createReducersFromManifest: () => createReducersFromManifest,
   daysBetween: () => daysBetween,
   formatDate: () => formatDate,
   formatDateTime: () => formatDateTime,
   generateSpanId: () => generateSpanId,
   generateTraceId: () => generateTraceId,
+  groupMenuSections: () => groupMenuSections,
+  hmsToSeconds: () => hmsToSeconds,
   initWebVitals: () => initWebVitals,
+  inspecaoModalReducer: () => inspecaoModalSlice_default,
   isBlank: () => isBlank,
   isDateAfter: () => isDateAfter,
   isDateBefore: () => isDateBefore,
+  isHostedByCore: () => isHostedByCore,
+  mantenedorPickerReducer: () => mantenedorPickerSlice_default,
+  pickMantenedorTipoReducer: () => pickMantenedorTipoSlice_default,
   pickTextColorBasedOnBgColorAdvanced: () => pickTextColorBasedOnBgColorAdvanced,
   pickerReducer: () => pickerReducer_default,
+  populateContador: () => populateContador,
+  populateInspecaoModal: () => populateInspecaoModal,
+  populateRecorrencia: () => populateRecorrencia,
   populateToEdit: () => populateToEdit,
+  populateUnidadeMaterial: () => populateUnidadeMaterial,
+  recorrenciaReducer: () => recorrenciaSlice_default,
   removeAccents: () => removeAccents,
+  removeContadorLimiteAt: () => removeContadorLimiteAt,
+  removeInspecaoLimiteAt: () => removeInspecaoLimiteAt,
+  resetPickMantenedorTipo: () => resetPickMantenedorTipo,
+  secondsToHms: () => secondsToHms,
+  selectContador: () => selectContador,
+  selectInspecaoModal: () => selectInspecaoModal,
+  selectRecorrencia: () => selectRecorrencia,
+  selectUnidadeMaterial: () => selectUnidadeMaterial,
   setColor: () => setColor,
+  setContadorParametro: () => setContadorParametro,
+  setContadorUnidade: () => setContadorUnidade,
+  setContadorValor: () => setContadorValor,
   setExcludeLevels: () => setExcludeLevels,
   setHaveComponente: () => setHaveComponente,
+  setInspecaoLimites: () => setInspecaoLimites,
+  setInspecaoNomeParametro: () => setInspecaoNomeParametro,
+  setInspecaoParametro: () => setInspecaoParametro,
+  setInspecaoTipo: () => setInspecaoTipo,
+  setInspecaoUnidadeParametro: () => setInspecaoUnidadeParametro,
   setLevel: () => setLevel,
   setLevels: () => setLevels,
+  setMantenedorError: () => setMantenedorError,
+  setMantenedorLoading: () => setMantenedorLoading,
+  setMantenedorOptions: () => setMantenedorOptions,
+  setMantenedorPendingConfirm: () => setMantenedorPendingConfirm,
+  setMantenedorSearchTerm: () => setMantenedorSearchTerm,
   setNome: () => setNome,
+  setPickMantenedorTipoAssigning: () => setPickMantenedorTipoAssigning,
+  setPickMantenedorTipoError: () => setPickMantenedorTipoError,
+  setPickMantenedorTipoLoading: () => setPickMantenedorTipoLoading,
+  setPickMantenedorTipoOptions: () => setPickMantenedorTipoOptions,
   setPickerContext: () => setPickerContext,
   setPickerItems: () => setPickerItems,
   setPickerSelected: () => setPickerSelected,
   setPickerVisible: () => setPickerVisible,
+  setRecorrenciaDataInicio: () => setRecorrenciaDataInicio,
+  setRecorrenciaEscala: () => setRecorrenciaEscala,
+  setRecorrenciaValor: () => setRecorrenciaValor,
+  setUnidadeMaterialMaterial: () => setMaterial,
+  setUnidadeMaterialQuantidade: () => setQuantidade,
+  setUnidadeMaterialUnidade: () => setUnidade,
   slugify: () => slugify,
   toISOString: () => toISOString,
   truncate: () => truncate,
+  unidadeMaterialReducer: () => unidadeMaterialSlice_default,
+  updateContadorLimiteAt: () => updateContadorLimiteAt,
+  useAnexoManager: () => useAnexoManager,
+  useAnexoManagerViewModel: () => useAnexoManagerViewModel,
   useAnexoUpload: () => useAnexoUpload,
+  useContadorViewModel: () => useContadorViewModel,
   useCoreService: () => useCoreService,
   useFetchData: () => useFetchData,
+  useFilterCombineMode: () => useFilterCombineMode,
+  useFindRecursoByTagViewModel: () => useFindRecursoByTagViewModel,
   useFormStorage: () => useFormStorage,
   useHttpController: () => useHttpController,
+  useInspecaoModalViewModel: () => useInspecaoModalViewModel,
+  useJustificativaModalViewModel: () => useJustificativaModalViewModel,
+  useMantenedorPickerViewModel: () => useMantenedorPickerViewModel,
   useMatchingObject: () => useMatchingObject,
   useNavigator: () => useNavigator,
   useNotifications: () => useNotifications,
   useObservability: () => useObservability,
+  useObservacoesTarefaViewModel: () => useObservacoesTarefaViewModel,
+  usePickMantenedorTipoViewModel: () => usePickMantenedorTipoViewModel,
   usePostData: () => usePostData,
+  useRecorrenciaViewModel: () => useRecorrenciaViewModel,
+  useRecursoDisplayerViewModel: () => useRecursoDisplayerViewModel,
   useSmartSearch: () => useSmartSearch,
+  useTarefaItemViewModel: () => useTarefaItemViewModel,
+  useTarefaStatusViewModel: () => useTarefaStatusViewModel,
+  useTimeFormat: () => useTimeFormat,
   useToast: () => useToast,
+  useUnidadeMaterialViewModel: () => useUnidadeMaterialViewModel,
   useValidation: () => useValidation
 });
 module.exports = __toCommonJS(index_exports);
@@ -180,6 +252,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()
 };
 
@@ -274,60 +347,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
+    };
+  }
+  /** 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) {
+  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 {
@@ -376,13 +507,15 @@ var CoreServiceBuilder = class {
     return this;
   }
   build() {
+    const subscriptions = [];
     return {
       toast: this._toast,
       createController: (context, baseEndPoint) => {
         if (this._fallbackControllers[context]) {
           return this._fallbackControllers[context];
         }
-        const endpoint = baseEndPoint != null ? baseEndPoint : this._httpEndpoint ? `${this._httpEndpoint}/${context}` : null;
+        const endpointStr = this._httpEndpoint ? context ? `${this._httpEndpoint}/${context}` : this._httpEndpoint : null;
+        const endpoint = baseEndPoint != null ? baseEndPoint : endpointStr;
         if (!endpoint) {
           console.warn(`[CoreServiceBuilder] HttpEndpoint nulo para "${context}". Usando NullHttpController.`);
           const controller = new NullHttpController();
@@ -396,19 +529,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: {}
     };
   }
 };
@@ -529,15 +670,207 @@ function useObservability() {
   return useCoreService().observability;
 }
 
-// src/hooks/useFetchData.ts
+// src/hooks/useAnexoManager.ts
 var import_react6 = require("react");
-function useFetchData() {
+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 [data, setData] = (0, import_react6.useState)(null);
+  const [persistidos, setPersistidos] = (0, import_react6.useState)([]);
+  const [locais, setLocais] = (0, import_react6.useState)([]);
   const [loading, setLoading] = (0, import_react6.useState)(false);
-  const [error, setError] = (0, import_react6.useState)(null);
-  const activeRef = (0, import_react6.useRef)(true);
-  const fetchData = (0, import_react6.useCallback)(
+  const anexoController = (0, import_react6.useMemo)(() => createController("anexo"), [createController]);
+  const getPort = (0, import_react6.useCallback)(() => {
+    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 = (0, import_react6.useCallback)(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 = (0, import_react6.useCallback)((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 = (0, import_react6.useCallback)((localId2) => {
+    setLocais((prev) => prev.filter((a) => a.localId !== localId2));
+  }, []);
+  const uploadAll = (0, import_react6.useCallback)(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 = (0, import_react6.useCallback)(async (anexoId) => {
+    try {
+      await getPort().remove(anexoId);
+      setPersistidos((prev) => prev.filter((a) => a.id !== anexoId));
+    } catch (e) {
+    }
+  }, [getPort]);
+  const getUrl = (0, import_react6.useCallback)(
+    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
+var import_react7 = require("react");
+function useFetchData() {
+  const { createController } = useCoreService();
+  const [data, setData] = (0, import_react7.useState)(null);
+  const [loading, setLoading] = (0, import_react7.useState)(false);
+  const [error, setError] = (0, import_react7.useState)(null);
+  const activeRef = (0, import_react7.useRef)(true);
+  const fetchData = (0, import_react7.useCallback)(
     async (context, path, endpoint) => {
       const controller = createController(context, endpoint);
       setLoading(true);
@@ -555,7 +888,7 @@ function useFetchData() {
     },
     [createController]
   );
-  const reset = (0, import_react6.useCallback)(() => {
+  const reset = (0, import_react7.useCallback)(() => {
     setData(null);
     setLoading(false);
     setError(null);
@@ -564,13 +897,13 @@ function useFetchData() {
 }
 
 // src/hooks/usePostData.ts
-var import_react7 = require("react");
+var import_react8 = require("react");
 function usePostData() {
   const { createController } = useCoreService();
-  const [result, setResult] = (0, import_react7.useState)(null);
-  const [loading, setLoading] = (0, import_react7.useState)(false);
-  const [error, setError] = (0, import_react7.useState)(null);
-  const postData = (0, import_react7.useCallback)(
+  const [result, setResult] = (0, import_react8.useState)(null);
+  const [loading, setLoading] = (0, import_react8.useState)(false);
+  const [error, setError] = (0, import_react8.useState)(null);
+  const postData = (0, import_react8.useCallback)(
     async (context, path, payload, endpoint) => {
       const controller = createController(context, endpoint);
       setLoading(true);
@@ -592,13 +925,13 @@ function usePostData() {
 }
 
 // src/hooks/useAnexoUpload.ts
-var import_react8 = require("react");
+var import_react9 = require("react");
 function useAnexoUpload() {
   const { createController } = useCoreService();
   const toast = useToast();
-  const [uploading, setUploading] = (0, import_react8.useState)(false);
-  const [progress, setProgress] = (0, import_react8.useState)(0);
-  const upload = (0, import_react8.useCallback)(
+  const [uploading, setUploading] = (0, import_react9.useState)(false);
+  const [progress, setProgress] = (0, import_react9.useState)(0);
+  const upload = (0, import_react9.useCallback)(
     async (context, path, file, extraHeaders) => {
       const controller = createController(context);
       setUploading(true);
@@ -621,7 +954,7 @@ function useAnexoUpload() {
     },
     [createController, toast]
   );
-  const uploadMultiple = (0, import_react8.useCallback)(
+  const uploadMultiple = (0, import_react9.useCallback)(
     async (context, path, files, extraHeaders) => {
       const fileArray = Array.from(files);
       const results = [];
@@ -639,10 +972,10 @@ function useAnexoUpload() {
 }
 
 // src/hooks/useFormStorage.ts
-var import_react9 = require("react");
+var import_react10 = require("react");
 function useFormStorage(key, initialValue) {
   const storageKey = `teraprox_form_${key}`;
-  const [value, setValue] = (0, import_react9.useState)(() => {
+  const [value, setValue] = (0, import_react10.useState)(() => {
     try {
       const stored = localStorage.getItem(storageKey);
       return stored ? JSON.parse(stored) : initialValue;
@@ -650,13 +983,13 @@ function useFormStorage(key, initialValue) {
       return initialValue;
     }
   });
-  (0, import_react9.useEffect)(() => {
+  (0, import_react10.useEffect)(() => {
     try {
       localStorage.setItem(storageKey, JSON.stringify(value));
     } catch (e) {
     }
   }, [value, storageKey]);
-  const clear = (0, import_react9.useCallback)(() => {
+  const clear = (0, import_react10.useCallback)(() => {
     localStorage.removeItem(storageKey);
     setValue(initialValue);
   }, [storageKey, initialValue]);
@@ -664,11 +997,11 @@ function useFormStorage(key, initialValue) {
 }
 
 // src/hooks/useSmartSearch.ts
-var import_react10 = require("react");
+var import_react11 = require("react");
 function useSmartSearch(data, searchFields, options) {
-  const [searchTerm, setSearchTerm] = (0, import_react10.useState)("");
+  const [searchTerm, setSearchTerm] = (0, import_react11.useState)("");
   const { caseSensitive = false, minLength = 1 } = options || {};
-  const filteredData = (0, import_react10.useMemo)(() => {
+  const filteredData = (0, import_react11.useMemo)(() => {
     if (!searchTerm || searchTerm.length < minLength) return data;
     const term = caseSensitive ? searchTerm : searchTerm.toLowerCase();
     return data.filter(
@@ -680,16 +1013,16 @@ function useSmartSearch(data, searchFields, options) {
       })
     );
   }, [data, searchTerm, searchFields, caseSensitive, minLength]);
-  const clearSearch = (0, import_react10.useCallback)(() => setSearchTerm(""), []);
+  const clearSearch = (0, import_react11.useCallback)(() => setSearchTerm(""), []);
   return { searchTerm, setSearchTerm, filteredData, clearSearch };
 }
 
 // src/hooks/useValidation.ts
-var import_react11 = require("react");
+var import_react12 = require("react");
 function useValidation(rules) {
   const toast = useToast();
-  const [errors, setErrors] = (0, import_react11.useState)({});
-  const validate = (0, import_react11.useCallback)(
+  const [errors, setErrors] = (0, import_react12.useState)({});
+  const validate = (0, import_react12.useCallback)(
     (form) => {
       const newErrors = {};
       let valid = true;
@@ -708,22 +1041,523 @@ function useValidation(rules) {
     },
     [rules, toast]
   );
-  const clearErrors = (0, import_react11.useCallback)(() => setErrors({}), []);
-  const setFieldError = (0, import_react11.useCallback)(
+  const clearErrors = (0, import_react12.useCallback)(() => setErrors({}), []);
+  const setFieldError = (0, import_react12.useCallback)(
     (field, message) => setErrors((prev) => ({ ...prev, [field]: message })),
     []
   );
   return { errors, validate, clearErrors, setFieldError };
 }
 
-// src/components/recurso/RecursoDisplayer.tsx
-var import_react17 = require("react");
-var import_react_bootstrap2 = require("react-bootstrap");
+// src/hooks/useTimeFormat.ts
+var import_dayjs = __toESM(require("dayjs"));
+var import_duration = __toESM(require("dayjs/plugin/duration.js"));
+import_dayjs.default.extend(import_duration.default);
+var secondsToHms = (seconds) => {
+  const s = typeof seconds === "number" && !Number.isNaN(seconds) ? seconds : 0;
+  return import_dayjs.default.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/hooks/useFilterCombineMode.ts
+var import_react13 = require("react");
+var FILTER_COMBINE_MODES = [
+  "union",
+  "intersection",
+  "xor"
+];
+var nextMode = {
+  union: "intersection",
+  intersection: "xor",
+  xor: "union"
+};
+function useFilterCombineMode(initialMode = "union") {
+  const [mode, setMode] = (0, import_react13.useState)(initialMode);
+  const cycleMode = (0, import_react13.useCallback)(() => {
+    setMode((prev) => nextMode[prev]);
+  }, []);
+  const matches = (0, import_react13.useCallback)(
+    (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 (0, import_react13.useMemo)(
+    () => ({ mode, setMode, cycleMode, matches }),
+    [mode, cycleMode, matches]
+  );
+}
+
+// src/viewmodels/ReduxUnidadeMaterialAdapter.ts
+var import_react14 = require("react");
 var import_react_redux3 = require("react-redux");
 
-// src/reducers/branchLevelReducer.ts
+// src/viewmodels/unidadeMaterialSlice.ts
 var import_toolkit = require("@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 = (0, import_toolkit.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 = (0, import_react_redux3.useDispatch)();
+  const toast = useToast();
+  const materialCtrl = useHttpController("material");
+  const unidadeCtrl = useHttpController("unidade");
+  const tarefaUnidadeMaterialCtrl = useHttpController("tarefaUnidadeMaterial");
+  const value = (0, import_react_redux3.useSelector)(
+    (state) => selectUnidadeMaterial(state, tarefaId)
+  );
+  const [isSubmitting, setIsSubmitting] = (0, import_react14.useState)(false);
+  const onMaterialSelected = (0, import_react14.useCallback)(
+    (material) => {
+      dispatch(setMaterial({ tarefaId, value: material != null ? material : null }));
+    },
+    [dispatch, tarefaId]
+  );
+  const onQuantidadeUpdate = (0, import_react14.useCallback)(
+    (qtd) => {
+      dispatch(setQuantidade({ tarefaId, value: qtd }));
+    },
+    [dispatch, tarefaId]
+  );
+  const onUnidadeSelected = (0, import_react14.useCallback)(
+    (unidade) => {
+      dispatch(setUnidade({ tarefaId, value: unidade != null ? unidade : null }));
+    },
+    [dispatch, tarefaId]
+  );
+  const loadMaterials = (0, import_react14.useCallback)(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 = (0, import_react14.useCallback)(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 = (0, import_react14.useCallback)(() => {
+    dispatch(clearUnidadeMaterial({ tarefaId }));
+  }, [dispatch, tarefaId]);
+  const populate = (0, import_react14.useCallback)(
+    (next) => {
+      dispatch(populateUnidadeMaterial({ tarefaId, value: next }));
+    },
+    [dispatch, tarefaId]
+  );
+  const validate = (0, import_react14.useCallback)(() => {
+    return runValidate(value);
+  }, [value]);
+  const reset = (0, import_react14.useCallback)(() => {
+    dispatch(clearUnidadeMaterial({ tarefaId }));
+  }, [dispatch, tarefaId]);
+  const submit = (0, import_react14.useCallback)(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 = (0, import_react14.useCallback)(
+    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 = (0, import_react14.useMemo)(() => runValidate(value).ok, [value]);
+  return (0, import_react14.useMemo)(
+    () => ({
+      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
+var import_react15 = require("react");
+var import_react_redux4 = require("react-redux");
+
+// src/viewmodels/inspecaoModalSlice.ts
+var import_toolkit2 = require("@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 = (0, import_toolkit2.createSlice)({
+  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 = (0, import_react_redux4.useDispatch)();
+  const value = (0, import_react_redux4.useSelector)(
+    (state) => selectInspecaoModal(state, tarefaId)
+  );
+  const [isSubmitting, setIsSubmitting] = (0, import_react15.useState)(false);
+  const onTipoDeDado = (0, import_react15.useCallback)(
+    (tipo) => {
+      dispatch(setInspecaoTipo({ tarefaId, value: tipo }));
+    },
+    [dispatch, tarefaId]
+  );
+  const onNomeParametro = (0, import_react15.useCallback)(
+    (nome) => {
+      dispatch(setInspecaoNomeParametro({ tarefaId, value: nome }));
+    },
+    [dispatch, tarefaId]
+  );
+  const onParametroSelected = (0, import_react15.useCallback)(
+    (parametro) => {
+      dispatch(setInspecaoParametro({ tarefaId, value: parametro }));
+    },
+    [dispatch, tarefaId]
+  );
+  const onUnidadeParametro = (0, import_react15.useCallback)(
+    (unidade) => {
+      dispatch(setInspecaoUnidadeParametro({ tarefaId, value: unidade }));
+    },
+    [dispatch, tarefaId]
+  );
+  const onLimitesChange = (0, import_react15.useCallback)(
+    (limites) => {
+      dispatch(setInspecaoLimites({ tarefaId, value: limites }));
+    },
+    [dispatch, tarefaId]
+  );
+  const removeLimite = (0, import_react15.useCallback)(
+    (idx) => {
+      dispatch(removeInspecaoLimiteAt({ tarefaId, idx }));
+    },
+    [dispatch, tarefaId]
+  );
+  const editLimite = (0, import_react15.useCallback)((_limite) => {
+  }, []);
+  const validate = (0, import_react15.useCallback)(() => {
+    return runValidate2(value);
+  }, [value]);
+  const reset = (0, import_react15.useCallback)(() => {
+    dispatch(clearInspecaoModal({ tarefaId }));
+  }, [dispatch, tarefaId]);
+  const populateFromExisting = (0, import_react15.useCallback)(
+    (inspecao) => {
+      dispatch(populateInspecaoModal({ tarefaId, value: inspecao }));
+    },
+    [dispatch, tarefaId]
+  );
+  const submit = (0, import_react15.useCallback)(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 = (0, import_react15.useMemo)(() => runValidate2(value).ok, [value]);
+  return (0, import_react15.useMemo)(
+    () => ({
+      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
+var import_react16 = require("react");
+var import_react_redux5 = require("react-redux");
+
+// src/reducers/branchLevelReducer.ts
+var import_toolkit3 = require("@reduxjs/toolkit");
+var initialState3 = {
   form: {
     nome: "",
     level: 0,
@@ -733,9 +1567,9 @@ var initialState = {
   },
   levels: []
 };
-var branchLevelSlice = (0, import_toolkit.createSlice)({
+var branchLevelSlice = (0, import_toolkit3.createSlice)({
   name: "branchLevelReducer",
-  initialState,
+  initialState: initialState3,
   reducers: {
     setNome(state, action) {
       state.form.nome = action.payload;
@@ -759,7 +1593,7 @@ var branchLevelSlice = (0, import_toolkit.createSlice)({
       state.form = action.payload;
     },
     clear(state) {
-      state.form = initialState.form;
+      state.form = initialState3.form;
     }
   }
 });
@@ -775,788 +1609,1282 @@ var {
 } = branchLevelSlice.actions;
 var branchLevelReducer_default = branchLevelSlice.reducer;
 
-// src/components/recurso/BranchDropDisplay.tsx
-var import_react12 = require("react");
-var import_fa = require("react-icons/fa");
-var import_md = require("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
-var import_jsx_runtime = require("react/jsx-runtime");
-var BranchDropDisplay = ({
-  branch,
-  addBranch,
-  multiMode,
-  setMultiMode,
-  onSaveRecurso,
-  backOnBranch,
-  branches,
-  singleReturn
-}) => {
-  const [fontColor, setFontColor] = (0, import_react12.useState)("#000");
-  const [searchTerm, setSearchTerm] = (0, import_react12.useState)("");
-  const [show, setShow] = (0, import_react12.useState)(false);
-  const [multiSelected, setMultiSelected] = (0, import_react12.useState)([]);
-  const dropdownRef = (0, import_react12.useRef)(null);
-  (0, import_react12.useEffect)(() => {
-    setFontColor(
-      pickTextColorBasedOnBgColorAdvanced(branch.branchLevel.color, "#FFFFFF", "#000000")
-    );
-  }, [branch.branchLevel.color]);
-  (0, import_react12.useEffect)(() => {
-    const handleClickOutside = (event) => {
-      if (dropdownRef.current && !dropdownRef.current.contains(event.target)) {
-        setShow(false);
+// src/viewmodels/ReduxRecursoDisplayerAdapter.ts
+function useRecursoDisplayerViewModel(overrides = {}) {
+  var _a, _b;
+  const dispatch = (0, import_react_redux5.useDispatch)();
+  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] = (0, import_react16.useState)([]);
+  const [isLoading, setIsLoading] = (0, import_react16.useState)(false);
+  const branchesRef = (0, import_react16.useRef)(branches);
+  (0, import_react16.useEffect)(() => {
+    branchesRef.current = branches;
+  }, [branches]);
+  const loadInitialBranches = (0, import_react16.useCallback)(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__ */ (0, import_jsx_runtime.jsxs)(
-    "div",
-    {
-      ref: dropdownRef,
-      style: {
-        position: "relative",
-        marginBottom: "0.5rem",
-        width: "100%",
-        fontFamily: "Arial, sans-serif"
-      },
-      children: [
-        /* @__PURE__ */ (0, import_jsx_runtime.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__ */ (0, import_jsx_runtime.jsxs)("span", { style: { overflow: "hidden", textOverflow: "ellipsis", whiteSpace: "nowrap" }, children: [
-                branch.nomeRecurso || branch.branchLevel.nome,
-                branch.nomeRecurso && !multiMode && isLastBranchClicked() && /* @__PURE__ */ (0, import_jsx_runtime.jsx)("em", { style: { fontStyle: "italic", opacity: 0.8, marginLeft: "0.5rem" }, children: "(Selecionado)" })
-              ] }),
-              /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_fa.FaChevronDown, {})
-            ]
+  }, [arvoreCtrl, branchLevelCtrl, dispatch]);
+  const advanceBranch = (0, import_react16.useCallback)(
+    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;
           }
-        ),
-        show && /* @__PURE__ */ (0, import_jsx_runtime.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__ */ (0, import_jsx_runtime.jsxs)(
-                "div",
-                {
-                  style: {
-                    display: "flex",
-                    alignItems: "center",
-                    padding: "0.5rem",
-                    borderBottom: "1px solid #ddd"
-                  },
-                  children: [
-                    /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_fa.FaSearch, { style: { marginRight: "0.5rem", color: "#555" } }),
-                    /* @__PURE__ */ (0, import_jsx_runtime.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__ */ (0, import_jsx_runtime.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__ */ (0, import_jsx_runtime.jsx)(import_fa.FaCheckSquare, { style: { marginRight: "0.5rem" } }),
-                    "Selecionar m\xFAltiplos"
-                  ]
-                }
-              ) : /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("div", { style: { display: "flex", gap: "0.5rem", margin: "0.5rem 0" }, children: [
-                /* @__PURE__ */ (0, import_jsx_runtime.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__ */ (0, import_jsx_runtime.jsx)(import_fa.FaCheck, { style: { marginRight: "0.5rem" } }),
-                      "Confirmar sele\xE7\xE3o"
-                    ]
-                  }
-                ),
-                /* @__PURE__ */ (0, import_jsx_runtime.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__ */ (0, import_jsx_runtime.jsx)(import_md.MdClose, { style: { marginRight: "0.5rem" } }),
-                      "Cancelar"
-                    ]
-                  }
-                )
-              ] }),
-              /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { style: { padding: "0.5rem" }, children: visibleNodes.map((bn) => {
-                const selected = multiMode ? multiSelected.some((r) => r.id === bn.recurso.id) : false;
-                return /* @__PURE__ */ (0, import_jsx_runtime.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__ */ (0, import_jsx_runtime.jsx)("span", { children: bn.recurso.nome }),
-                      selected && /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_fa.FaCheck, {})
-                    ]
-                  },
-                  bn.recurso.id
-                );
-              }) })
-            ]
+        );
+        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);
+            }
+          } catch (e) {
+            console.warn(
+              "[RecursoDisplayerVM] Failed to fetch child branch:",
+              e
+            );
           }
-        )
-      ]
-    }
+        }
+        setBranches([...branchsToStay]);
+      } finally {
+        setIsLoading(false);
+      }
+    },
+    [arvoreCtrl]
   );
-};
-var BranchDropDisplay_default = BranchDropDisplay;
+  const backToBranch = (0, import_react16.useCallback)((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);
+        }
+      )
+    );
+  }, []);
+  const reset = (0, import_react16.useCallback)(() => {
+    setBranches([]);
+  }, []);
+  return (0, import_react16.useMemo)(
+    () => ({
+      branches,
+      isLoading,
+      loadInitialBranches,
+      advanceBranch,
+      backToBranch,
+      reset
+    }),
+    [branches, isLoading, loadInitialBranches, advanceBranch, backToBranch, reset]
+  );
+}
 
-// src/components/recurso/FindRecursoByTagField.tsx
-var import_react16 = require("react");
-var import_gr = require("react-icons/gr");
+// src/viewmodels/ReduxFindRecursoByTagAdapter.ts
+var import_react17 = require("react");
+function useFindRecursoByTagViewModel(overrides = {}) {
+  var _a;
+  const defaultRecurso = useHttpController("recurso");
+  const recursoCtrl = (_a = overrides.recursoController) != null ? _a : defaultRecurso;
+  const [isSearching, setIsSearching] = (0, import_react17.useState)(false);
+  const loadActiveTags = (0, import_react17.useCallback)(async () => {
+    try {
+      const res = await recursoCtrl.get("findActiveRecursosTags");
+      return Array.isArray(res) ? res : [];
+    } catch (err) {
+      console.warn("[FindRecursoByTagVM] loadActiveTags failed:", err);
+      return [];
+    }
+  }, [recursoCtrl]);
+  const searchByTagId = (0, import_react17.useCallback)(
+    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 = (0, import_react17.useCallback)(
+    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 (0, import_react17.useMemo)(
+    () => ({
+      isSearching,
+      loadActiveTags,
+      searchByTagId,
+      searchByTag
+    }),
+    [isSearching, loadActiveTags, searchByTagId, searchByTag]
+  );
+}
 
-// src/components/recurso/AutoComplete.tsx
-var import_react13 = require("react");
-var import_react_bootstrap = require("react-bootstrap");
-var import_jsx_runtime2 = require("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] = (0, import_react13.useState)([]);
-  const [options, setOptions] = (0, import_react13.useState)([]);
-  const [input, setInput] = (0, import_react13.useState)("");
-  const [hide, setHide] = (0, import_react13.useState)(true);
-  const [onLoaded, setOnLoaded] = (0, import_react13.useState)(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])));
-  };
-  (0, import_react13.useEffect)(() => {
-    if (value) setInput(value);
-    else setInput("");
-  }, [value]);
-  (0, import_react13.useEffect)(() => {
-    const sortedOptions = sortOptions(ops, sortKey);
-    setListItem(sortedOptions);
-    setOptions(sortedOptions);
-  }, [ops, sortKey]);
-  (0, import_react13.useEffect)(() => {
-    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 sortedOptions = sortOptions(newOps, sortKey);
-            setListItem(sortedOptions);
-            setOptions(sortedOptions);
-          }
-          if (onLoad) {
-            if (onLoaded) return;
-            setOnLoaded(true);
-            onLoad(newOps);
-          }
-        } catch (e) {
-          setListItem([]);
+// src/viewmodels/ReduxJustificativaModalAdapter.ts
+var import_react18 = require("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] = (0, import_react18.useState)(
+    initialJustificativas
+  );
+  const [draft, setDraft] = (0, import_react18.useState)("");
+  const [editingId, setEditingId] = (0, import_react18.useState)(null);
+  const [isSubmitting, setIsSubmitting] = (0, import_react18.useState)(false);
+  const initialRef = (0, import_react18.useRef)(initialJustificativas);
+  (0, import_react18.useEffect)(() => {
+    initialRef.current = initialJustificativas;
+    setJustificativas(initialJustificativas);
+  }, [initialJustificativas]);
+  const commit = (0, import_react18.useCallback)(
+    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 = (0, import_react18.useCallback)(
+    (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 = (0, import_react18.useCallback)(() => {
+    setEditingId(null);
+    setDraft("");
+  }, []);
+  const addOrEdit = (0, import_react18.useCallback)(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);
+    }
+  }, [draft, editingId, justificativas, currentUser, commit]);
+  const remove = (0, import_react18.useCallback)(
+    async (id) => {
+      const next = justificativas.map(
+        (j) => j.id === id ? { ...j, removed: true } : j
+      );
+      return commit(next);
+    },
+    [justificativas, commit]
+  );
+  const undoRemove = (0, import_react18.useCallback)(
+    async (id) => {
+      const next = justificativas.map(
+        (j) => j.id === id ? { ...j, removed: false } : j
+      );
+      return commit(next);
+    },
+    [justificativas, commit]
+  );
+  const validate = (0, import_react18.useCallback)(
+    () => runValidate3(draft),
+    [draft]
+  );
+  const reset = (0, import_react18.useCallback)(() => {
+    setJustificativas(initialRef.current);
+    setDraft("");
+    setEditingId(null);
+  }, []);
+  const populateFromExisting = (0, import_react18.useCallback)((list) => {
+    initialRef.current = list;
+    setJustificativas(list);
+    setDraft("");
+    setEditingId(null);
+  }, []);
+  return (0, import_react18.useMemo)(
+    () => ({
+      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
+var import_react19 = require("react");
+function useAnexoManagerViewModel(opts) {
+  const base = useAnexoManager(opts);
+  return (0, import_react19.useMemo)(
+    () => ({
+      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
+var import_react20 = require("react");
+var import_react_redux6 = require("react-redux");
+
+// src/viewmodels/recorrenciaSlice.ts
+var import_toolkit4 = require("@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
     };
-    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;
-        }
-        return regex.test(textToTest);
-      });
-      setListItem(newListItem);
-    } else {
-      setListItem(options);
+    state.byEntity[key] = fresh;
+    return fresh;
+  }
+  return existing;
+};
+var recorrenciaSlice = (0, import_toolkit4.createSlice)({
+  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;
     }
-    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);
+  }
+});
+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 = (0, import_react_redux6.useDispatch)();
+  const value = (0, import_react_redux6.useSelector)(
+    (state) => selectRecorrencia(state, entityId)
+  );
+  const [isSubmitting, setIsSubmitting] = (0, import_react20.useState)(false);
+  const onValorChange = (0, import_react20.useCallback)(
+    (valor) => {
+      dispatch(setRecorrenciaValor({ entityId, value: valor }));
+    },
+    [dispatch, entityId]
+  );
+  const onEscalaChange = (0, import_react20.useCallback)(
+    (escala) => {
+      dispatch(setRecorrenciaEscala({ entityId, value: escala }));
+    },
+    [dispatch, entityId]
+  );
+  const onDataInicioChange = (0, import_react20.useCallback)(
+    (dataInicio) => {
+      dispatch(setRecorrenciaDataInicio({ entityId, value: dataInicio }));
+    },
+    [dispatch, entityId]
+  );
+  const clear = (0, import_react20.useCallback)(() => {
+    dispatch(clearRecorrencia({ entityId }));
+  }, [dispatch, entityId]);
+  const populateFromExisting = (0, import_react20.useCallback)(
+    (next) => {
+      dispatch(populateRecorrencia({ entityId, value: next }));
+    },
+    [dispatch, entityId]
+  );
+  const validate = (0, import_react20.useCallback)(
+    () => runValidate4(value),
+    [value]
+  );
+  const submit = (0, import_react20.useCallback)(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);
     }
-    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__ */ (0, import_jsx_runtime2.jsx)("li", { children: buildedString }, index);
-  };
-  const boldedPart = (text, key) => {
-    return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("li", { children: text }, key);
+  }, [value]);
+  const isValid = (0, import_react20.useMemo)(() => runValidate4(value).ok, [value]);
+  return (0, import_react20.useMemo)(
+    () => ({
+      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
+var import_react21 = require("react");
+var import_react_redux7 = require("react-redux");
+
+// src/viewmodels/contadorSlice.ts
+var import_toolkit5 = require("@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 = (0, import_toolkit5.createSlice)({
+  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: [] };
+    }
+  }
+});
+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 displayListItens = (li, index) => {
-    if (formatationFunc) {
-      return boldedPart(formatationFunc(li), index);
+};
+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.";
     }
-    if (displayKey) {
-      return boldedPart(li[displayKey], 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 (displayKeys) {
-      return renderMoreThanOneKey(li, index);
+    if (!(l == null ? void 0 : l.boundRule)) {
+      errors[`limitesDeControle[${idx}].boundRule`] = "Regra de compara\xE7\xE3o \xE9 obrigat\xF3ria.";
     }
-    return boldedPart(li, index);
-  };
-  const onKeyDownHandler = (event) => {
-    if (event.key === "Escape") {
-      setHide(true);
-      onEscKeyDown && onEscKeyDown();
+    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 /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(
-    "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__ */ (0, import_jsx_runtime2.jsxs)(import_jsx_runtime2.Fragment, { children: [
-          useStandardLabel && title && /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(import_react_bootstrap.Form.Label, { children: [
-            title,
-            isRequired && " *"
-          ] }),
-          /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(import_react_bootstrap.InputGroup, { children: [
-            useStandardLabel ? /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
-              import_react_bootstrap.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__ */ (0, import_jsx_runtime2.jsx)(import_react_bootstrap.FloatingLabel, { style: { zIndex: 0 }, label: title, controlId: "floatingInput", children: /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
-              import_react_bootstrap.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__ */ (0, import_jsx_runtime2.jsx)(import_react_bootstrap.ListGroup, { className: "listgroup-autocomplete", hidden: hide, children: liItem.map((li, index) => /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_react_bootstrap.ListGroup.Item, { action: true, onClick: () => onOpSelected(li, index, liItem), children: displayListItens(li, index) }, index)) })
-      ]
+  });
+  return { ok: Object.keys(errors).length === 0, errors };
+}
+function useContadorViewModel(entityId) {
+  const dispatch = (0, import_react_redux7.useDispatch)();
+  const value = (0, import_react_redux7.useSelector)(
+    (state) => selectContador(state, entityId)
+  );
+  const [isSubmitting, setIsSubmitting] = (0, import_react21.useState)(false);
+  const onValorChange = (0, import_react21.useCallback)(
+    (v) => {
+      dispatch(setContadorValor({ entityId, value: v }));
+    },
+    [dispatch, entityId]
+  );
+  const onUnidadeChange = (0, import_react21.useCallback)(
+    (u) => {
+      dispatch(setContadorUnidade({ entityId, value: u }));
+    },
+    [dispatch, entityId]
+  );
+  const onParametroChange = (0, import_react21.useCallback)(
+    (p) => {
+      dispatch(setContadorParametro({ entityId, value: p }));
+    },
+    [dispatch, entityId]
+  );
+  const onLimiteAdd = (0, import_react21.useCallback)(
+    (limite) => {
+      dispatch(addContadorLimite({ entityId, value: limite }));
+    },
+    [dispatch, entityId]
+  );
+  const onLimiteRemove = (0, import_react21.useCallback)(
+    (index) => {
+      dispatch(removeContadorLimiteAt({ entityId, index }));
+    },
+    [dispatch, entityId]
+  );
+  const onLimiteUpdate = (0, import_react21.useCallback)(
+    (index, limite) => {
+      dispatch(updateContadorLimiteAt({ entityId, index, value: limite }));
+    },
+    [dispatch, entityId]
+  );
+  const validate = (0, import_react21.useCallback)(
+    () => runValidate5(value),
+    [value]
+  );
+  const reset = (0, import_react21.useCallback)(() => {
+    dispatch(clearContador({ entityId }));
+  }, [dispatch, entityId]);
+  const populateFromExisting = (0, import_react21.useCallback)(
+    (next) => {
+      dispatch(populateContador({ entityId, value: next }));
+    },
+    [dispatch, entityId]
+  );
+  const submit = (0, import_react21.useCallback)(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 = (0, import_react21.useMemo)(() => runValidate5(value).ok, [value]);
+  return (0, import_react21.useMemo)(
+    () => ({
+      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
+    ]
   );
-};
-var AutoComplete_default = AutoComplete;
+}
 
-// src/components/recurso/QrCodeScanButton.tsx
-var import_react15 = require("react");
-var import_bs = require("react-icons/bs");
+// src/viewmodels/useMantenedorPickerViewModel.ts
+var import_react22 = require("react");
+var import_react_redux8 = require("react-redux");
 
-// src/components/recurso/QrReader.tsx
-var import_qr_scanner = __toESM(require("qr-scanner"));
-var import_react14 = require("react");
-var import_jsx_runtime3 = require("react/jsx-runtime");
-var QrReader = ({ callback }) => {
-  const scanner = (0, import_react14.useRef)(null);
-  const videoEl = (0, import_react14.useRef)(null);
-  const qrBoxEl = (0, import_react14.useRef)(null);
-  const [qrOn, setQrOn] = (0, import_react14.useState)(true);
-  const [scannedResult, setScannedResult] = (0, import_react14.useState)("");
-  const onScanSuccess = (result) => {
-    setScannedResult(result == null ? void 0 : result.data);
-    callback(result == null ? void 0 : result.data);
-  };
-  const onScanFail = (err) => {
-    console.error(err);
-  };
-  (0, import_react14.useEffect)(() => {
-    if ((videoEl == null ? void 0 : videoEl.current) && !scanner.current) {
-      scanner.current = new import_qr_scanner.default(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
+var import_toolkit6 = require("@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 = (0, import_toolkit6.createSlice)({
+  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 = (0, import_react_redux8.useDispatch)();
+  const core = useCoreService();
+  const slot = (0, import_react_redux8.useSelector)(
+    (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 = (0, import_react22.useCallback)(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 }
+        );
       }
-    };
-  }, []);
-  (0, import_react14.useEffect)(() => {
-    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__ */ (0, import_jsx_runtime3.jsxs)("div", { className: "qr-reader", children: [
-    /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("video", { ref: videoEl }),
-    /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("div", { ref: qrBoxEl, className: "qr-box" }),
-    scannedResult && /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)(
-      "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]);
+  (0, import_react22.useEffect)(() => {
+    refresh();
+  }, [key]);
+  const search = (0, import_react22.useCallback)(
+    (term) => {
+      dispatch(setMantenedorSearchTerm({ key, term }));
+    },
+    [dispatch, key]
+  );
+  const requestSelect = (0, import_react22.useCallback)(
+    (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 = (0, import_react22.useCallback)(() => {
+    const item = pendingConfirm;
+    dispatch(setMantenedorPendingConfirm({ key, item: null }));
+    return item;
+  }, [dispatch, key, pendingConfirm]);
+  const cancelConfirm = (0, import_react22.useCallback)(() => {
+    dispatch(setMantenedorPendingConfirm({ key, item: null }));
+  }, [dispatch, key]);
+  const reset = (0, import_react22.useCallback)(() => {
+    dispatch(clearMantenedorSlot({ key }));
+  }, [dispatch, key]);
+  const filteredOptions = (0, import_react22.useMemo)(() => {
+    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 (0, import_react22.useMemo)(
+    () => ({
+      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
-var import_jsx_runtime4 = require("react/jsx-runtime");
-var QrCodeScanButton = ({ callback }) => {
-  const [showQr, setShowQr] = (0, import_react15.useState)(false);
-  const qrShowHandler = () => {
-    setShowQr((prev) => !prev);
-  };
-  return /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)(
-    "div",
-    {
-      className: "hoverable-div",
-      style: {
-        border: "solid",
-        borderTopRightRadius: "3px",
-        borderBottomRightRadius: "3px",
-        padding: "8px",
-        borderLeft: "none",
-        borderColor: "#ccc",
-        borderWidth: "1px"
-      },
-      children: [
-        showQr && /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(
-          QrReader_default,
-          {
-            callback: (v) => {
-              qrShowHandler();
-              callback(v);
-            }
-          }
-        ),
-        /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(
-          import_bs.BsQrCode,
-          {
-            size: 25,
-            onClick: () => {
-              qrShowHandler();
-            }
-          }
-        )
-      ]
+// src/viewmodels/ReduxTarefaStatusAdapter.ts
+var import_react23 = require("react");
+function useTarefaStatusViewModel(opts) {
+  const { tarefaId, fatherId, initialStatus = "PENDENTE" } = opts;
+  const { createController } = useCoreService();
+  const toast = useToast();
+  const [current, setCurrent] = (0, import_react23.useState)(initialStatus);
+  const [saving, setSaving] = (0, import_react23.useState)(false);
+  const tarefaCtrl = (0, import_react23.useMemo)(
+    () => createController("tarefa"),
+    [createController]
+  );
+  const toggle = (0, import_react23.useCallback)(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 (0, import_react23.useMemo)(
+    () => ({ current, toggle, saving }),
+    [current, toggle, saving]
   );
-};
-var QrCodeScanButton_default = QrCodeScanButton;
+}
 
-// src/components/recurso/FindRecursoByTagField.tsx
-var import_jsx_runtime5 = require("react/jsx-runtime");
-var FindRecursoByTagField = ({ callback }) => {
-  const recursoController = useHttpController("recurso");
-  const [selectedTag, setSelectedTag] = (0, import_react16.useState)(null);
-  const [reachedRecurso, setReachedRecurso] = (0, import_react16.useState)(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__ */ (0, import_jsx_runtime5.jsx)(
-    "div",
-    {
-      className: "hoverable-div",
-      style: {
-        border: "solid",
-        borderTopRightRadius: "3px",
-        borderBottomRightRadius: "3px",
-        padding: "8px",
-        borderLeft: "none",
-        borderColor: "#ccc",
-        borderWidth: "1px"
-      },
-      children: /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(import_gr.GrCheckmark, { size: 25, onClick: () => callback(reachedRecurso, true) })
-    }
+// src/viewmodels/ReduxObservacoesTarefaAdapter.ts
+var import_react24 = require("react");
+function useObservacoesTarefaViewModel(opts) {
+  const { tarefaId } = opts;
+  const { createController } = useCoreService();
+  const toast = useToast();
+  const [list, setList] = (0, import_react24.useState)([]);
+  const [loading, setLoading] = (0, import_react24.useState)(false);
+  const tarefaCtrl = (0, import_react24.useMemo)(
+    () => createController("tarefa"),
+    [createController]
   );
-  return /* @__PURE__ */ (0, import_jsx_runtime5.jsx)("div", { children: /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(
-    AutoComplete_default,
-    {
-      sortKey: "id",
-      loadCondition: true,
-      loadFunc: () => recursoController.get("findActiveRecursosTags"),
-      displayKey: "descricao",
-      title: "Selecione ou Digite a TAG",
-      isBold: true,
-      actionButton: confirmRecursoSelectionButton,
-      actionButton2: () => /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(
-        QrCodeScanButton_default,
-        {
-          callback: (description) => findRecursoByTagDescriptionHandler(description)
-        }
-      ),
-      onSelectedClick: (v) => {
-        setSelectedTag(v);
-        findRecursoByTagIdHandler(v.id);
-      },
-      value: selectedTag == null ? void 0 : selectedTag.descricao
+  const load = (0, import_react24.useCallback)(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 = (0, import_react24.useCallback)(
+    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 (0, import_react24.useMemo)(
+    () => ({ list, loading, load, add }),
+    [list, loading, load, add]
+  );
+}
+
+// src/viewmodels/usePickMantenedorTipoViewModel.ts
+var import_react25 = require("react");
+var import_react_redux9 = require("react-redux");
+
+// src/viewmodels/pickMantenedorTipoSlice.ts
+var import_toolkit7 = require("@reduxjs/toolkit");
+var initialState7 = {
+  mantenedores: [],
+  tiposDeOrdem: [],
+  loading: false,
+  assigning: false,
+  error: null
 };
-var FindRecursoByTagField_default = FindRecursoByTagField;
+var slice2 = (0, import_toolkit7.createSlice)({
+  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
-var import_jsx_runtime6 = require("react/jsx-runtime");
-var RecursoDisplayer = ({
-  selectedList = [],
-  onSaveRecurso,
-  singleReturn = false
-}) => {
-  const arvoreEstruturalController = useHttpController("arvoreEstrutural");
-  const branchLevelController = useHttpController("branchLevel");
-  const [branches, setBranches] = (0, import_react17.useState)([]);
-  const dispatch = (0, import_react_redux3.useDispatch)();
-  const [localSelected, setLocalSelected] = (0, import_react17.useState)(selectedList);
-  const [selectorDisplay, setSelectorDisplay] = (0, import_react17.useState)("");
-  const [multiMode, setMultiMode] = (0, import_react17.useState)(false);
-  (0, import_react17.useEffect)(() => {
-    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__ */ (0, import_jsx_runtime6.jsxs)("div", { style: { width: "100%", padding: 0 }, children: [
-    /* @__PURE__ */ (0, import_jsx_runtime6.jsx)("div", { className: "d-flex justify-content-between align-items-center mb-3", children: /* @__PURE__ */ (0, import_jsx_runtime6.jsxs)("div", { children: [
-      /* @__PURE__ */ (0, import_jsx_runtime6.jsx)("label", { className: "me-2", children: "Selecionar Recurso Por:" }),
-      /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(
-        import_react_bootstrap2.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 = (0, import_react_redux9.useDispatch)();
+  const core = useCoreService();
+  const state = (0, import_react_redux9.useSelector)(
+    (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 = (0, import_react25.useCallback)(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 = (0, import_react25.useCallback)(
+    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__ */ (0, import_jsx_runtime6.jsx)(
-        import_react_bootstrap2.Button,
-        {
-          size: "sm",
-          onClick: () => setSelectorDisplay("TAG"),
-          variant: selectorDisplay === "TAG" ? "primary" : "outline-primary",
-          children: "TAG"
+      } finally {
+        dispatch(setPickMantenedorTipoAssigning(false));
+      }
+    },
+    [dispatch, core]
+  );
+  const assignTipo = (0, import_react25.useCallback)(
+    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 = (0, import_react25.useCallback)(
+    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__ */ (0, import_jsx_runtime6.jsx)(
-      BranchDropDisplay_default,
-      {
-        branch,
-        addBranch: branchSetter,
-        multiMode,
-        setMultiMode,
-        onSaveRecurso,
-        backOnBranch,
-        branches,
-        singleReturn
-      },
-      branch.id || i
-    )),
-    selectorDisplay === "TAG" && /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(
-      FindRecursoByTagField_default,
-      {
-        callback: (rec, checked) => {
-          setLocalSelected([rec]);
-          onSaveRecurso([rec], checked);
+      } finally {
+        dispatch(setPickMantenedorTipoAssigning(false));
+      }
+    },
+    [dispatch, core]
+  );
+  const assignTipoMultiOs = (0, import_react25.useCallback)(
+    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 = (0, import_react25.useCallback)(() => {
+    dispatch(resetPickMantenedorTipo());
+  }, [dispatch]);
+  return (0, import_react25.useMemo)(
+    () => ({
+      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
+var import_react26 = require("react");
+function useTarefaItemViewModel(opts) {
+  const { tarefaId, mode, fatherId, initialStatus } = opts;
+  const { createController, subscribe, unsubscribe } = useCoreService();
+  const toast = useToast();
+  const tarefaCtrl = (0, import_react26.useMemo)(
+    () => 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 = (0, import_react26.useRef)(observacoes);
+  observacoesRef.current = observacoes;
+  const anexosRef = (0, import_react26.useRef)(anexos);
+  anexosRef.current = anexos;
+  const updateDescricao = (0, import_react26.useCallback)(
+    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 = (0, import_react26.useCallback)(() => {
+    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 (0, import_react26.useMemo)(
+    () => ({
+      status,
+      observacoes,
+      inspecao,
+      unidadeMaterial,
+      anexos,
+      updateDescricao,
+      subscribeLive
+    }),
+    [
+      status,
+      observacoes,
+      inspecao,
+      unidadeMaterial,
+      anexos,
+      updateDescricao,
+      subscribeLive
+    ]
+  );
+}
 
 // src/reducers/pickerReducer.ts
-var import_toolkit2 = require("@reduxjs/toolkit");
-var initialState2 = {
+var import_toolkit8 = require("@reduxjs/toolkit");
+var initialState8 = {
   selected: null,
   items: [],
   visible: false,
   context: ""
 };
-var pickerSlice = (0, import_toolkit2.createSlice)({
+var pickerSlice = (0, import_toolkit8.createSlice)({
   name: "picker",
-  initialState: initialState2,
+  initialState: initialState8,
   reducers: {
     setPickerSelected(state, action) {
       state.selected = action.payload;
@@ -1571,7 +2899,7 @@ var pickerSlice = (0, import_toolkit2.createSlice)({
       state.context = action.payload;
     },
     clearPicker() {
-      return initialState2;
+      return initialState8;
     }
   }
 });
@@ -1584,6 +2912,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;
@@ -1618,28 +2960,28 @@ function initWebVitals(observability) {
 }
 
 // src/utils/dateUtils.ts
-var import_dayjs = __toESM(require("dayjs"));
+var import_dayjs2 = __toESM(require("dayjs"));
 function formatDate(date, format = "DD/MM/YYYY") {
   if (!date) return "";
-  return (0, import_dayjs.default)(date).format(format);
+  return (0, import_dayjs2.default)(date).format(format);
 }
 function formatDateTime(date) {
   return formatDate(date, "DD/MM/YYYY HH:mm");
 }
 function isDateBefore(date1, date2) {
-  return (0, import_dayjs.default)(date1).isBefore((0, import_dayjs.default)(date2));
+  return (0, import_dayjs2.default)(date1).isBefore((0, import_dayjs2.default)(date2));
 }
 function isDateAfter(date1, date2) {
-  return (0, import_dayjs.default)(date1).isAfter((0, import_dayjs.default)(date2));
+  return (0, import_dayjs2.default)(date1).isAfter((0, import_dayjs2.default)(date2));
 }
 function daysBetween(start, end) {
-  return (0, import_dayjs.default)(end).diff((0, import_dayjs.default)(start), "day");
+  return (0, import_dayjs2.default)(end).diff((0, import_dayjs2.default)(start), "day");
 }
 function addDays(date, days) {
-  return (0, import_dayjs.default)(date).add(days, "day").toDate();
+  return (0, import_dayjs2.default)(date).add(days, "day").toDate();
 }
 function toISOString(date) {
-  return (0, import_dayjs.default)(date).toISOString();
+  return (0, import_dayjs2.default)(date).toISOString();
 }
 
 // src/utils/stringUtils.ts
@@ -1662,10 +3004,10 @@ function isBlank(str) {
 }
 
 // src/federation/FederatedBridge.tsx
-var import_react18 = require("react");
-var import_jsx_runtime7 = require("react/jsx-runtime");
+var import_react27 = require("react");
+var import_jsx_runtime = require("react/jsx-runtime");
 function FederatedBridge({ coreService, children }) {
-  (0, import_react18.useEffect)(() => {
+  (0, import_react27.useEffect)(() => {
     if (typeof window === "undefined") return;
     window.__TERAPROX_HOSTED_BY_CORE__ = true;
     return () => {
@@ -1673,28 +3015,81 @@ function FederatedBridge({ coreService, children }) {
       window.__TERAPROX_HOSTED_BY_CORE__ = false;
     };
   }, []);
-  return /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(CoreServiceContext.Provider, { value: coreService, children });
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(CoreServiceContext.Provider, { value: coreService, children });
+}
+
+// src/federation/isHostedByCore.ts
+function isHostedByCore() {
+  if (typeof window === "undefined") return false;
+  return !!window.__TERAPROX_HOSTED_BY_CORE__;
 }
 
 // src/federation/createReducersBundle.ts
+function buildGetReducersForKeys(reducers) {
+  return async (keys = []) => {
+    const uniqueKeys = [...new Set(keys)].filter((key) => !!reducers[key]);
+    const loaded = await Promise.all(
+      uniqueKeys.map(async (key) => {
+        const mod = await reducers[key]();
+        return [key, mod.default || mod];
+      })
+    );
+    return Object.fromEntries(loaded);
+  };
+}
+function createReducersFromManifest(manifest, reducerMap, defaultReducerKeys = []) {
+  var _a, _b, _c, _d, _e, _f;
+  const allKeys = Object.keys(reducerMap);
+  const getReducersForKeys = buildGetReducersForKeys(reducerMap);
+  const allRoutes = [];
+  for (const section of (_a = manifest.menuSections) != null ? _a : []) {
+    allRoutes.push(...(_b = section.items) != null ? _b : []);
+  }
+  allRoutes.push(...(_c = manifest.formRoutes) != null ? _c : []);
+  const derivedContextMap = {};
+  for (const route of allRoutes) {
+    if (!route.context) continue;
+    const routeReducers = (_d = route.reducers) != null ? _d : [];
+    const existing = (_e = derivedContextMap[route.context]) != null ? _e : [];
+    derivedContextMap[route.context] = [.../* @__PURE__ */ new Set([...existing, ...routeReducers])];
+  }
+  const mergedDefaults = [
+    .../* @__PURE__ */ new Set([...defaultReducerKeys, ...(_f = manifest.defaultReducers) != null ? _f : []])
+  ];
+  const getReducerKeysByContext = (context) => {
+    const contextKeys = derivedContextMap[context];
+    if (!contextKeys || contextKeys.length === 0) return allKeys;
+    return [.../* @__PURE__ */ new Set([...mergedDefaults, ...contextKeys])];
+  };
+  const getReducersForModule = async ({
+    context,
+    reducerKeys
+  } = {}) => {
+    if (reducerKeys && reducerKeys.length > 0) {
+      const keys2 = [.../* @__PURE__ */ new Set([...mergedDefaults, ...reducerKeys])];
+      return getReducersForKeys(keys2);
+    }
+    const keys = getReducerKeysByContext(context || "");
+    return getReducersForKeys(keys);
+  };
+  const loadAllReducers = () => getReducersForKeys(allKeys);
+  return {
+    getReducerKeysByContext,
+    getReducersForKeys,
+    getReducersForModule,
+    loadAllReducers,
+    baseReducers: {}
+  };
+}
 function createReducersBundle(config) {
   const { reducers, contextMap, defaults = [] } = config;
   const allKeys = Object.keys(reducers);
+  const getReducersForKeys = buildGetReducersForKeys(reducers);
   const getReducerKeysByContext = (context) => {
     const contextKeys = contextMap[context];
     if (!contextKeys) return allKeys;
     return [.../* @__PURE__ */ new Set([...defaults, ...contextKeys])];
   };
-  const getReducersForKeys = async (keys = []) => {
-    const uniqueKeys = [...new Set(keys)].filter((key) => !!reducers[key]);
-    const loaded = await Promise.all(
-      uniqueKeys.map(async (key) => {
-        const module2 = await reducers[key]();
-        return [key, module2.default || module2];
-      })
-    );
-    return Object.fromEntries(loaded);
-  };
   const getReducersForModule = async ({
     context
   } = {}) => {
@@ -1712,8 +3107,8 @@ function createReducersBundle(config) {
 }
 
 // src/federation/StandaloneProvider.tsx
-var import_react19 = require("react");
-var import_jsx_runtime8 = require("react/jsx-runtime");
+var import_react28 = require("react");
+var import_jsx_runtime2 = require("react/jsx-runtime");
 async function probeEmulator(host, port) {
   try {
     const res = await fetch(`http://${host}:${port}/.json`, {
@@ -1752,7 +3147,7 @@ async function resolveRtdbStrategy(firebaseConfig, emulator) {
 }
 var _emulatorConnected = /* @__PURE__ */ new Set();
 function RtdbConfigWarning({ onDismiss }) {
-  return /* @__PURE__ */ (0, import_jsx_runtime8.jsxs)(
+  return /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(
     "div",
     {
       style: {
@@ -1772,28 +3167,28 @@ function RtdbConfigWarning({ onDismiss }) {
         lineHeight: 1.6
       },
       children: [
-        /* @__PURE__ */ (0, import_jsx_runtime8.jsx)("div", { style: { fontWeight: "bold", marginBottom: 8, color: "#f59e0b", fontSize: 14 }, children: "\u26A0 RTDB n\xE3o configurado" }),
-        /* @__PURE__ */ (0, import_jsx_runtime8.jsxs)("div", { children: [
+        /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("div", { style: { fontWeight: "bold", marginBottom: 8, color: "#f59e0b", fontSize: 14 }, children: "\u26A0 RTDB n\xE3o configurado" }),
+        /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)("div", { children: [
           "Matching Objects em tempo real desativados.",
-          /* @__PURE__ */ (0, import_jsx_runtime8.jsx)("br", {}),
+          /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("br", {}),
           "Configure no ",
-          /* @__PURE__ */ (0, import_jsx_runtime8.jsx)("code", { children: ".env.dev" }),
+          /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("code", { children: ".env.dev" }),
           ":",
-          /* @__PURE__ */ (0, import_jsx_runtime8.jsx)("br", {}),
-          /* @__PURE__ */ (0, import_jsx_runtime8.jsx)("code", { style: { color: "#86efac" }, children: "REACT_APP_RTDB_EMULATOR_HOST=localhost:9000" }),
-          /* @__PURE__ */ (0, import_jsx_runtime8.jsx)("br", {}),
-          /* @__PURE__ */ (0, import_jsx_runtime8.jsxs)("span", { style: { color: "#94a3b8", fontSize: 11 }, children: [
+          /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("br", {}),
+          /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("code", { style: { color: "#86efac" }, children: "REACT_APP_RTDB_EMULATOR_HOST=localhost:9000" }),
+          /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("br", {}),
+          /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)("span", { style: { color: "#94a3b8", fontSize: 11 }, children: [
             "ou inicie o backend com ",
-            /* @__PURE__ */ (0, import_jsx_runtime8.jsx)("code", { children: "RtdbEmulatorPlugin" }),
+            /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("code", { children: "RtdbEmulatorPlugin" }),
             " do @onroad/core"
           ] }),
-          /* @__PURE__ */ (0, import_jsx_runtime8.jsx)("br", {}),
-          /* @__PURE__ */ (0, import_jsx_runtime8.jsxs)("span", { style: { color: "#94a3b8", fontSize: 11 }, children: [
+          /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("br", {}),
+          /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)("span", { style: { color: "#94a3b8", fontSize: 11 }, children: [
             "e rode o emulator com ",
-            /* @__PURE__ */ (0, import_jsx_runtime8.jsx)("code", { children: "firebase emulators:start --only database" })
+            /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("code", { children: "firebase emulators:start --only database" })
           ] })
         ] }),
-        /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(
+        /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
           "button",
           {
             onClick: onDismiss,
@@ -1814,27 +3209,45 @@ function RtdbConfigWarning({ onDismiss }) {
     }
   );
 }
-function StandaloneProvider({ createController, addToast, firebaseConfig, emulator, tenant, children }) {
-  const [subscriptions] = (0, import_react19.useState)([]);
-  const subscriptionsRef = (0, import_react19.useRef)(subscriptions);
+function StandaloneProvider({
+  createController,
+  toast: toastProp,
+  addToast,
+  firebaseConfig,
+  emulator,
+  tenant,
+  children
+}) {
+  const [subscriptions] = (0, import_react28.useState)([]);
+  const subscriptionsRef = (0, import_react28.useRef)(subscriptions);
   subscriptionsRef.current = subscriptions;
-  const [rtdbWarning, setRtdbWarning] = (0, import_react19.useState)(false);
-  const toast = (0, import_react19.useMemo)(
-    () => ({
-      success: (msg, opts) => addToast(msg, { appearance: "success", autoDismiss: true, ...opts }),
-      warning: (msg, opts) => addToast(msg, { appearance: "warning", autoDismiss: true, ...opts }),
-      error: (msg, opts) => addToast(msg, { appearance: "error", autoDismiss: true, ...opts }),
-      info: (msg, opts) => addToast(msg, { appearance: "info", autoDismiss: true, ...opts })
-    }),
-    [addToast]
-  );
-  const subscribe = (0, import_react19.useCallback)(
+  const [rtdbWarning, setRtdbWarning] = (0, import_react28.useState)(false);
+  const _envTenant = typeof process !== "undefined" ? process.env.REACT_APP_RTDB_TENANT : void 0;
+  const resolvedTenant = tenant || _envTenant || (process.env.NODE_ENV !== "production" ? "dev-local" : void 0);
+  const toast = (0, import_react28.useMemo)(() => {
+    if (toastProp) return toastProp;
+    if (addToast) {
+      return {
+        success: (msg, opts) => addToast(msg, { appearance: "success", autoDismiss: true, ...opts }),
+        warning: (msg, opts) => addToast(msg, { appearance: "warning", autoDismiss: true, ...opts }),
+        error: (msg, opts) => addToast(msg, { appearance: "error", autoDismiss: true, ...opts }),
+        info: (msg, opts) => addToast(msg, { appearance: "info", autoDismiss: true, ...opts })
+      };
+    }
+    const noop = (msg) => {
+      if (process.env.NODE_ENV !== "production") {
+        console.warn("[StandaloneProvider] Toast called but no toast/addToast prop provided:", msg);
+      }
+    };
+    return { success: noop, warning: noop, error: noop, info: noop };
+  }, [toastProp, addToast]);
+  const subscribe = (0, import_react28.useCallback)(
     (mo) => {
       subscriptions.push(mo);
     },
     [subscriptions]
   );
-  const unsubscribe = (0, import_react19.useCallback)(
+  const unsubscribe = (0, import_react28.useCallback)(
     (mo) => {
       const idx = subscriptions.findIndex(
         (s) => s.context === mo.context && s.location === mo.location
@@ -1843,8 +3256,17 @@ function StandaloneProvider({ createController, addToast, firebaseConfig, emulat
     },
     [subscriptions]
   );
-  (0, import_react19.useEffect)(() => {
-    if (!tenant) return;
+  (0, import_react28.useEffect)(() => {
+    if (resolvedTenant || process.env.NODE_ENV === "production") return;
+    const timer = setTimeout(() => {
+      console.warn(
+        '[StandaloneProvider] RTDB listener deferred: tenant could not be resolved after 5 s.\nFix with any of:\n  \u2022 Pass `tenant` prop (e.g. from Redux state.global.companyId)\n  \u2022 Set REACT_APP_RTDB_TENANT=<companyId> in your .env\n  \u2022 Run in NODE_ENV=development (auto-falls back to "dev-local")'
+      );
+    }, 5e3);
+    return () => clearTimeout(timer);
+  }, [resolvedTenant]);
+  (0, import_react28.useEffect)(() => {
+    if (!resolvedTenant) return;
     let cleanup;
     let cancelled = false;
     (async () => {
@@ -1887,7 +3309,7 @@ function StandaloneProvider({ createController, addToast, firebaseConfig, emulat
           const cloudApp = existingApp != null ? existingApp : initializeApp(strategy.config);
           db = getDatabase(cloudApp);
         }
-        const moRef = ref(db, `${tenant}/matchingObjects`);
+        const moRef = ref(db, `${resolvedTenant}/matchingObjects`);
         const unsub = onChildAdded(moRef, (snapshot) => {
           const data = snapshot.val();
           if (!data) return;
@@ -1917,8 +3339,8 @@ function StandaloneProvider({ createController, addToast, firebaseConfig, emulat
       cancelled = true;
       cleanup == null ? void 0 : cleanup();
     };
-  }, [firebaseConfig, emulator, tenant]);
-  const value = (0, import_react19.useMemo)(
+  }, [firebaseConfig, emulator, resolvedTenant]);
+  const value = (0, import_react28.useMemo)(
     () => ({
       createController,
       toast,
@@ -1931,20 +3353,21 @@ function StandaloneProvider({ createController, addToast, firebaseConfig, emulat
       handleLogout: () => {
       },
       hostedByCore: false,
-      observability: new NullObservabilityAdapter()
+      observability: new NullObservabilityAdapter(),
+      rateLimits: {}
     }),
     [createController, toast, subscribe, unsubscribe]
   );
-  return /* @__PURE__ */ (0, import_jsx_runtime8.jsxs)(CoreServiceContext.Provider, { value, children: [
+  return /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(CoreServiceContext.Provider, { value, children: [
     children,
-    rtdbWarning && /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(RtdbConfigWarning, { onDismiss: () => setRtdbWarning(false) })
+    rtdbWarning && /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(RtdbConfigWarning, { onDismiss: () => setRtdbWarning(false) })
   ] });
 }
 
 // src/federation/DevAutoLogin.tsx
-var import_react20 = require("react");
-var import_react_redux4 = require("react-redux");
-var import_jsx_runtime9 = require("react/jsx-runtime");
+var import_react29 = require("react");
+var import_react_redux10 = require("react-redux");
+var import_jsx_runtime3 = require("react/jsx-runtime");
 var DEFAULT_DEV_USER = {
   firstName: "Dev",
   lastName: "User",
@@ -1961,79 +3384,237 @@ var DEFAULT_DEV_USER = {
   filters: []
 };
 function DevAutoLogin({ actions, devUser, children }) {
-  const dispatch = (0, import_react_redux4.useDispatch)();
-  const token = (0, import_react_redux4.useSelector)((state) => {
+  const dispatch = (0, import_react_redux10.useDispatch)();
+  const token = (0, import_react_redux10.useSelector)((state) => {
     var _a;
     return (_a = state.global) == null ? void 0 : _a.token;
   });
   const hostedByCore = typeof window !== "undefined" && window.__TERAPROX_HOSTED_BY_CORE__ === true;
-  (0, import_react20.useEffect)(() => {
+  (0, import_react29.useEffect)(() => {
     if (process.env.NODE_ENV === "development" && !hostedByCore && !token) {
       const user = { ...DEFAULT_DEV_USER, ...devUser };
       dispatch(actions.setCompany(user.companyId));
       dispatch(actions.logIn(user));
     }
   }, [dispatch, hostedByCore, token, actions, devUser]);
-  return /* @__PURE__ */ (0, import_jsx_runtime9.jsx)(import_jsx_runtime9.Fragment, { children });
+  return /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(import_jsx_runtime3.Fragment, { children });
+}
+
+// src/federation/groupMenuSections.ts
+function groupMenuSections(manifests) {
+  var _a, _b, _c, _d, _e, _f, _g;
+  const groupMap = /* @__PURE__ */ new Map();
+  const topLevel = [];
+  for (const manifest of manifests) {
+    const fallbackGroup = manifest.menuGroup;
+    for (const section of (_a = manifest.menuSections) != null ? _a : []) {
+      const groupName = (_b = section.group) != null ? _b : fallbackGroup == null ? void 0 : fallbackGroup.name;
+      if (!groupName) {
+        topLevel.push({
+          key: `${manifest.name}:${section.label}`,
+          label: section.label,
+          icon: section.icon,
+          order: (_c = section.order) != null ? _c : 999,
+          children: section.items.map((item) => ({ kind: "item", item }))
+        });
+        continue;
+      }
+      let groupNode = groupMap.get(groupName);
+      if (!groupNode) {
+        groupNode = {
+          key: `group:${groupName}`,
+          label: groupName,
+          icon: (_d = fallbackGroup == null ? void 0 : fallbackGroup.icon) != null ? _d : section.icon,
+          order: (_f = (_e = fallbackGroup == null ? void 0 : fallbackGroup.order) != null ? _e : section.order) != null ? _f : 999,
+          children: []
+        };
+        groupMap.set(groupName, groupNode);
+      } else if (!groupNode.icon) {
+        const candidate = (_g = fallbackGroup == null ? void 0 : fallbackGroup.icon) != null ? _g : section.icon;
+        if (candidate) groupNode.icon = candidate;
+      }
+      if (section.flatten) {
+        for (const item of section.items) {
+          groupNode.children.push({ kind: "item", item, order: section.order });
+        }
+      } else {
+        const existing = groupNode.children.find(
+          (c) => c.kind === "section" && c.label === section.label
+        );
+        if (existing) {
+          existing.items = [...existing.items, ...section.items];
+          if (!existing.icon && section.icon) existing.icon = section.icon;
+          if (section.order != null && (existing.order == null || section.order < existing.order)) {
+            existing.order = section.order;
+          }
+        } else {
+          groupNode.children.push({
+            kind: "section",
+            label: section.label,
+            icon: section.icon,
+            items: [...section.items],
+            order: section.order
+          });
+        }
+      }
+    }
+  }
+  for (const node of groupMap.values()) {
+    node.children.sort((a, b) => {
+      var _a2, _b2, _c2, _d2;
+      const oa = (_a2 = a.order) != null ? _a2 : 999;
+      const ob = (_b2 = b.order) != null ? _b2 : 999;
+      if (oa !== ob) return oa - ob;
+      const la = a.kind === "section" ? a.label : (_c2 = a.item.label) != null ? _c2 : "";
+      const lb = b.kind === "section" ? b.label : (_d2 = b.item.label) != null ? _d2 : "";
+      return la.localeCompare(lb);
+    });
+    for (const child of node.children) {
+      if (child.kind === "section") {
+        child.items.sort((a, b) => {
+          var _a2, _b2, _c2, _d2;
+          const oa = (_a2 = a.order) != null ? _a2 : 999;
+          const ob = (_b2 = b.order) != null ? _b2 : 999;
+          if (oa !== ob) return oa - ob;
+          return ((_c2 = a.label) != null ? _c2 : "").localeCompare((_d2 = b.label) != null ? _d2 : "");
+        });
+      }
+    }
+  }
+  const all = [...topLevel, ...groupMap.values()];
+  all.sort((a, b) => a.order - b.order || a.label.localeCompare(b.label));
+  return all;
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  CONTADOR_DEFAULT_KEY,
   CoreServiceBuilder,
   CoreServiceContext,
   DevAutoLogin,
+  FILTER_COMBINE_MODES,
   FederatedBridge,
   FetchHttpAdapter,
+  INSPECAO_MODAL_DEFAULT_KEY,
   NullCoreService,
   NullHttpController,
   NullObservabilityAdapter,
   NullToastService,
-  RecursoDisplayer,
+  RECORRENCIA_DEFAULT_KEY,
   StandaloneProvider,
   TracingHttpAdapter,
+  UNIDADE_MATERIAL_DEFAULT_KEY,
+  addContadorLimite,
   addDays,
   branchLevelReducer,
   buildTraceparent,
   capitalize,
   clearBranchLevelForm,
+  clearContador,
+  clearInspecaoModal,
+  clearMantenedorSlot,
   clearPicker,
+  clearRecorrencia,
+  clearUnidadeMaterial,
+  contadorReducer,
   createReducersBundle,
+  createReducersFromManifest,
   daysBetween,
   formatDate,
   formatDateTime,
   generateSpanId,
   generateTraceId,
+  groupMenuSections,
+  hmsToSeconds,
   initWebVitals,
+  inspecaoModalReducer,
   isBlank,
   isDateAfter,
   isDateBefore,
+  isHostedByCore,
+  mantenedorPickerReducer,
+  pickMantenedorTipoReducer,
   pickTextColorBasedOnBgColorAdvanced,
   pickerReducer,
+  populateContador,
+  populateInspecaoModal,
+  populateRecorrencia,
   populateToEdit,
+  populateUnidadeMaterial,
+  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,
+  setUnidadeMaterialMaterial,
+  setUnidadeMaterialQuantidade,
+  setUnidadeMaterialUnidade,
   slugify,
   toISOString,
   truncate,
+  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
 });