@unvired/turboforms-embed-sdk 1.0.10 → 1.0.12

package/dist/unvired-forms-sdk.js

@@ -141,7 +141,7 @@ function sendEventCallback({
   if (type === "ERROR") {
     eventStructure = {
       type: "ERROR",
-      errorMessage,
+      errorMessage: errorMessage + ", contact your admin or tech team",
       data
     };
   } else {
@@ -223,11 +223,11 @@ async function validateAttachments(template, submissionData, sendEventCallback2)
           if (typeof fileId === "string" && fileId.trim()) {
             try {
               const fileRecord = await getFileFromIndexedDB(fileId);
-              if (!fileRecord || !fileRecord.id || !fileRecord.data || !fileRecord.url) {
+              if (!fileRecord || !fileRecord.id || !fileRecord.data && !fileRecord.url) {
                 missingFiles.push({
                   fileId,
                   field: key,
-                  reason: fileRecord ? "Incomplete file record (missing id/data/url)" : "File not found in IndexedDB"
+                  reason: fileRecord ? "Incomplete file record (missing id and data/url)" : "File not found in IndexedDB"
                 });
               }
             } catch (err) {
@@ -281,6 +281,7 @@ function getFileFromIndexedDB(fileId) {
 // src/lib/FileProcessor.js
 async function processFileIds(data, sendEventCallback2) {
   if (!data || typeof data !== "object") return data;
+  const clonedData = JSON.parse(JSON.stringify(data));
   async function traverse(obj) {
     for (const key in obj) {
       const value = obj[key];
@@ -298,21 +299,12 @@ async function processFileIds(data, sendEventCallback2) {
                 type: fileObject.type,
                 url: fileObject.url,
                 key,
-                uid: value[i]
+                uid: value[i],
+                mode: fileObject.mode || "G"
+                // Fix: Preserve the mode or default to G
               });
             } else {
               console.warn(`File not found in IndexedDB: ${value[i]} - removing from submission data`);
-              if (sendEventCallback2) {
-                sendEventCallback2({
-                  type: "ERROR",
-                  errorMessage: `ErrorCode : 015, contact your admin or tech team`,
-                  data: {
-                    reason: `File not found in IndexedDB: ${value[i]}`,
-                    fileId: value[i],
-                    field: key
-                  }
-                });
-              }
             }
           } else if (typeof value[i] === "object" && value[i] !== null) {
             await traverse(value[i]);
@@ -327,14 +319,25 @@ async function processFileIds(data, sendEventCallback2) {
       }
     }
   }
-  await traverse(data);
-  return data;
+  await traverse(clonedData);
+  return clonedData;
 }
 async function getFileFromIndexedDB2(fileId) {
   return new Promise((resolve) => {
     const request = indexedDB.open("Forms-Attachments", 3);
+    request.onupgradeneeded = (e) => {
+      const db = e.target.result;
+      if (!db.objectStoreNames.contains("Files")) {
+        db.createObjectStore("Files");
+      }
+    };
     request.onsuccess = (event) => {
       const db = event.target.result;
+      if (!db.objectStoreNames.contains("Files")) {
+        console.warn("Files store not found");
+        resolve(null);
+        return;
+      }
       const store = db.transaction(["Files"], "readonly").objectStore("Files");
       const getRequest = store.get(fileId);
       getRequest.onsuccess = () => resolve(getRequest.result);
@@ -344,6 +347,473 @@ async function getFileFromIndexedDB2(fileId) {
   });
 }
 
+// src/lib/dynamicValueProcessor.js
+function processDynamicValues(formJson, appData) {
+  if (!formJson || !formJson.components) return null;
+  let dataMap = {};
+  const hasAppData = appData && (Array.isArray(appData) && appData.length > 0 || !Array.isArray(appData) && Object.keys(appData).length > 0);
+  if (hasAppData) {
+    if (Array.isArray(appData)) {
+      appData.forEach((item) => {
+        if (item.key) dataMap[item.key] = item.value;
+      });
+    } else {
+      dataMap = appData || {};
+    }
+  }
+  function processComponents(comps) {
+    if (!comps || !Array.isArray(comps)) return null;
+    for (const comp of comps) {
+      if (typeof comp.defaultValue === "string" && comp.defaultValue.trim().startsWith("{{") && comp.defaultValue.trim().endsWith("}}")) {
+        const key = comp.defaultValue.trim();
+        if (hasAppData && dataMap[key] !== void 0) {
+          comp.defaultValue = dataMap[key];
+        }
+      }
+      let err;
+      if (comp.components) {
+        err = processComponents(comp.components);
+        if (err) return err;
+      }
+      if (comp.columns && Array.isArray(comp.columns)) {
+        for (const col of comp.columns) {
+          err = processComponents(col.components);
+          if (err) return err;
+        }
+      }
+      if (comp.rows && Array.isArray(comp.rows)) {
+        for (const row of comp.rows) {
+          if (Array.isArray(row)) {
+            for (const cell of row) {
+              err = processComponents(cell.components);
+              if (err) return err;
+            }
+          }
+        }
+      }
+    }
+    return null;
+  }
+  return processComponents(formJson.components);
+}
+
+// src/lib/appDocuments.js
+var DB_NAME = "AppDocuments";
+var STORE_NAME = "documents";
+var STORE_NAME_TYPO = "documnets";
+function openDB(version) {
+  if (version) {
+    return new Promise((resolve, reject) => {
+      const request = indexedDB.open(DB_NAME, version);
+      request.onupgradeneeded = (event) => {
+        const db = event.target.result;
+        if (!db.objectStoreNames.contains(STORE_NAME) && !db.objectStoreNames.contains(STORE_NAME_TYPO)) {
+          db.createObjectStore(STORE_NAME, { keyPath: "id", autoIncrement: true });
+        }
+      };
+      request.onsuccess = (event) => resolve(event.target.result);
+      request.onerror = (event) => {
+        console.error("AppDocuments DB error:", event.target.error);
+        reject(event.target.error);
+      };
+    });
+  }
+  if (typeof window !== "undefined" && window.indexedDBUtils && window.indexedDBUtils.openDynamicDB) {
+    return window.indexedDBUtils.openDynamicDB(DB_NAME, STORE_NAME, STORE_NAME_TYPO);
+  }
+  return new Promise((resolve, reject) => {
+    const checkRequest = indexedDB.open(DB_NAME);
+    checkRequest.onupgradeneeded = (e) => {
+      const db = e.target.result;
+      if (!db.objectStoreNames.contains(STORE_NAME) && !db.objectStoreNames.contains(STORE_NAME_TYPO)) {
+        db.createObjectStore(STORE_NAME, { keyPath: "id", autoIncrement: true });
+      }
+    };
+    checkRequest.onsuccess = (e) => {
+      const db = e.target.result;
+      if (db.objectStoreNames.contains(STORE_NAME) || db.objectStoreNames.contains(STORE_NAME_TYPO)) {
+        resolve(db);
+        return;
+      }
+      const currentVersion = db.version;
+      const newVersion = currentVersion + 1;
+      db.close();
+      console.log(`[AppDocuments] Store missing. Upgrading from v${currentVersion} to v${newVersion}.`);
+      const upgradeRequest = indexedDB.open(DB_NAME, newVersion);
+      upgradeRequest.onupgradeneeded = (evt) => {
+        const upgradeDb = evt.target.result;
+        if (!upgradeDb.objectStoreNames.contains(STORE_NAME)) {
+          upgradeDb.createObjectStore(STORE_NAME, { keyPath: "id", autoIncrement: true });
+        }
+      };
+      upgradeRequest.onsuccess = (evt) => resolve(evt.target.result);
+      upgradeRequest.onerror = (evt) => {
+        console.error("[AppDocuments] DB Upgrade failed:", evt);
+        reject(evt);
+      };
+    };
+    checkRequest.onerror = (e) => {
+      console.error("[AppDocuments] DB Open failed:", e);
+      reject(e.target.error);
+    };
+  });
+}
+function getStoreName(db) {
+  if (db.objectStoreNames.contains(STORE_NAME)) return STORE_NAME;
+  if (db.objectStoreNames.contains(STORE_NAME_TYPO)) return STORE_NAME_TYPO;
+  return null;
+}
+async function hasDocuments() {
+  try {
+    const db = await openDB();
+    const actualStoreName = getStoreName(db);
+    if (!actualStoreName) {
+      console.warn(`AppDocuments DB found but no '${STORE_NAME}' or '${STORE_NAME_TYPO}' store exists.`);
+      db.close();
+      return false;
+    }
+    return new Promise((resolve) => {
+      const transaction = db.transaction([actualStoreName], "readonly");
+      const store = transaction.objectStore(actualStoreName);
+      const countRequest = store.count();
+      countRequest.onsuccess = () => {
+        console.log(`[AppDocuments] Count in ${actualStoreName}:`, countRequest.result);
+        db.close();
+        resolve(countRequest.result > 0);
+      };
+      countRequest.onerror = (e) => {
+        console.error("[AppDocuments] Error counting:", e);
+        db.close();
+        resolve(false);
+      };
+    });
+  } catch (e) {
+    console.error("[AppDocuments] Error checking documents:", e);
+    return false;
+  }
+}
+async function getAllDocuments() {
+  try {
+    const db = await openDB();
+    const actualStoreName = getStoreName(db);
+    if (!actualStoreName) {
+      db.close();
+      return [];
+    }
+    return new Promise((resolve) => {
+      const transaction = db.transaction([actualStoreName], "readonly");
+      const store = transaction.objectStore(actualStoreName);
+      const request = store.getAll();
+      request.onsuccess = () => {
+        db.close();
+        resolve(request.result);
+      };
+      request.onerror = () => {
+        db.close();
+        resolve([]);
+      };
+    });
+  } catch (e) {
+    console.error("Error getting documents:", e);
+    return [];
+  }
+}
+async function insertDocument(doc) {
+  try {
+    let db = await openDB();
+    let actualStoreName = getStoreName(db);
+    if (!actualStoreName) {
+      db.close();
+      throw new Error("Failed to open database with valid store.");
+    }
+    return new Promise((resolve, reject) => {
+      const transaction = db.transaction([actualStoreName], "readwrite");
+      const store = transaction.objectStore(actualStoreName);
+      const request = store.add(doc);
+      request.onsuccess = () => {
+        db.close();
+        resolve(request.result);
+      };
+      request.onerror = (e) => {
+        db.close();
+        reject(e.target.error);
+      };
+    });
+  } catch (e) {
+    console.error("Error inserting document:", e);
+    throw e;
+  }
+}
+async function deleteDocument(id) {
+  try {
+    const db = await openDB();
+    const actualStoreName = getStoreName(db);
+    if (!actualStoreName) {
+      db.close();
+      console.error("No valid document store found for deletion");
+      return;
+    }
+    return new Promise((resolve, reject) => {
+      const transaction = db.transaction([actualStoreName], "readwrite");
+      const store = transaction.objectStore(actualStoreName);
+      const request = store.delete(id);
+      request.onsuccess = () => {
+        db.close();
+        resolve();
+      };
+      request.onerror = (e) => {
+        db.close();
+        reject(e.target.error);
+      };
+    });
+  } catch (e) {
+    console.error("Error deleting document:", e);
+    throw e;
+  }
+}
+
+// src/html-template/utils/openDocumentsModal.js
+var DB_NAME2 = "AppDocuments";
+var STORE_NAME2 = "documents";
+var STORE_NAME_TYPO2 = "documnets";
+function openDB2() {
+  return new Promise((resolve, reject) => {
+    const request = indexedDB.open(DB_NAME2);
+    request.onsuccess = (event) => resolve(event.target.result);
+    request.onerror = (event) => reject(event.target.error);
+  });
+}
+function getStoreName2(db) {
+  if (db.objectStoreNames.contains(STORE_NAME2)) return STORE_NAME2;
+  if (db.objectStoreNames.contains(STORE_NAME_TYPO2)) return STORE_NAME_TYPO2;
+  return null;
+}
+async function getAllDocuments2() {
+  try {
+    const db = await openDB2();
+    const actualStoreName = getStoreName2(db);
+    if (!actualStoreName) {
+      db.close();
+      return [];
+    }
+    return new Promise((resolve) => {
+      const transaction = db.transaction([actualStoreName], "readonly");
+      const store = transaction.objectStore(actualStoreName);
+      const request = store.getAll();
+      request.onsuccess = () => {
+        db.close();
+        resolve(request.result);
+      };
+      request.onerror = () => {
+        db.close();
+        resolve([]);
+      };
+    });
+  } catch (e) {
+    console.warn("Error reading AppDocuments DB:", e);
+    return [];
+  }
+}
+async function openDocumentsModal() {
+  if (typeof window.showDynamicModal !== "function") {
+    console.error("showDynamicModal is not defined.");
+    return;
+  }
+  window.showDynamicModal("App Documents", [], `
+    <div style="text-align: center; padding: 40px;">
+      <i class="fa fa-spinner fa-spin" style="font-size: 30px; color: #2185d0;"></i>
+      <div style="margin-top: 15px; color: #666; font-size: 16px;">Loading documents...</div>
+    </div>
+    `);
+  try {
+    const docs = await getAllDocuments2();
+    let bodyContent = "";
+    if (docs && docs.length > 0) {
+      bodyContent = `<div class="ui middle aligned divided list" style="width:100%;margin:0;">`;
+      docs.forEach((doc) => {
+        const name = doc.name || doc.title || "Untitled Document";
+        const desc = doc.description || "";
+        let metaInfo = "";
+        let iconClass = "file outline";
+        if (doc.type) {
+          if (doc.type.includes("pdf")) iconClass = "file pdf outline red";
+          else if (doc.type.includes("image")) iconClass = "file image outline blue";
+          else if (doc.type.includes("text")) iconClass = "file text outline grey";
+        }
+        if (Number.isInteger(doc.id)) {
+          metaInfo = new Date(doc.id).toLocaleDateString();
+        }
+        bodyContent += `
+                <div class="item" style="padding:12px 10px;display:flex;align-items:center;">
+                  <i class="${iconClass} icon large" style="margin-right:15px;"></i>
+
+                  <div class="content" style="flex:1;min-width:0;">
+                    <div class="header" style="white-space:nowrap;overflow:hidden;text-overflow:ellipsis;">
+                      ${name}
+                    </div>
+                    ${desc ? `<div class="description" style="font-size:12px;color:#666;">${desc}</div>` : ""}
+                    ${metaInfo ? `<div class="meta" style="font-size:11px;color:#999;">${metaInfo}</div>` : ""}
+                  </div>
+
+                  <button class="ui button mini basic primary"
+                    onclick="window.downloadDocument(${doc.id})">
+                    <i class="download icon"></i> Download
+                  </button>
+                </div>`;
+      });
+      bodyContent += `</div>`;
+    } else {
+      bodyContent = `
+            <div style="text-align:center;padding:50px;color:#999;">
+              <i class="folder open outline icon" style="font-size:40px;"></i>
+              <div>No documents available</div>
+            </div>`;
+    }
+    window.showDynamicModal(
+      "App Documents",
+      [{ label: "Close", callback: () => {
+      }, className: "ui button" }],
+      bodyContent
+    );
+    if (!window.downloadDocument) {
+      window.downloadDocument = async function(id) {
+        const all = await getAllDocuments2();
+        const found = all.find((d) => d.id == id);
+        if (!found) {
+          console.log("\u274C Document not found.");
+          if (window.sendEventCallback) {
+            window.sendEventCallback({
+              type: "ERROR",
+              errorMessage: "ErrorCode : 017, Document not found",
+              data: { reason: "Document not found", technicalError: null }
+            });
+          }
+          return;
+        }
+        console.log("Downloading:", found);
+        let incomingData = found.url || found.data || found.file && found.file.data;
+        let downloadUrl = null;
+        if (incomingData && incomingData.startsWith("data:")) {
+          const comma = incomingData.indexOf(",");
+          if (comma === -1) {
+            console.log("\u274C Invalid file format.");
+            if (window.sendEventCallback) {
+              window.sendEventCallback({
+                type: "ERROR",
+                errorMessage: "ErrorCode : 018, Invalid file format",
+                data: { reason: "Invalid file format", technicalError: null }
+              });
+            }
+            return;
+          }
+          const header = incomingData.substring(0, comma);
+          let base64 = incomingData.substring(comma + 1);
+          const mimeMatch = header.match(/:(.*?);/);
+          const mime = mimeMatch ? mimeMatch[1] : "application/octet-stream";
+          base64 = base64.replace(/\s/g, "");
+          if (!/^[A-Za-z0-9+/=]+$/.test(base64)) {
+            console.error("Invalid base64:", base64.slice(0, 50));
+            console.log("\u274C File is corrupted (invalid base64).");
+            if (window.sendEventCallback) {
+              window.sendEventCallback({
+                type: "ERROR",
+                errorMessage: "ErrorCode : 019, File is corrupted (invalid base64)",
+                data: { reason: "File is corrupted (invalid base64)", technicalError: null }
+              });
+            }
+            return;
+          }
+          try {
+            const binary = atob(base64);
+            const bytes = new Uint8Array(binary.length);
+            for (let i = 0; i < binary.length; i++) {
+              bytes[i] = binary.charCodeAt(i);
+            }
+            const blob = new Blob([bytes], { type: mime });
+            if (!blob.size) {
+              console.log("\u274C File is empty.");
+              if (window.sendEventCallback) {
+                window.sendEventCallback({
+                  type: "ERROR",
+                  errorMessage: "ErrorCode : 020, File is empty",
+                  data: { reason: "File is empty", technicalError: null }
+                });
+              }
+              return;
+            }
+            downloadUrl = URL.createObjectURL(blob);
+          } catch (err) {
+            console.error("Base64 decode failed:", err);
+            if (err.name === "InvalidCharacterError") {
+              console.log("\u274C File is corrupted (invalid encoding).");
+              if (window.sendEventCallback) {
+                window.sendEventCallback({
+                  type: "ERROR",
+                  errorMessage: "ErrorCode : 021, File is corrupted (invalid encoding)",
+                  data: { reason: "File is corrupted (invalid encoding)", technicalError: err }
+                });
+              }
+            } else {
+              console.log("\u274C Failed to process file.");
+              if (window.sendEventCallback) {
+                window.sendEventCallback({
+                  type: "ERROR",
+                  errorMessage: "ErrorCode : 022, Failed to process file",
+                  data: { reason: "Failed to process file", technicalError: err }
+                });
+              }
+            }
+            return;
+          }
+        } else if (found.file instanceof Blob) {
+          if (!found.file.size) {
+            console.log("\u274C File is empty.");
+            if (window.sendEventCallback) {
+              window.sendEventCallback({
+                type: "ERROR",
+                errorMessage: "ErrorCode : 023, File is empty",
+                data: { reason: "File is empty", technicalError: null }
+              });
+            }
+            return;
+          }
+          downloadUrl = URL.createObjectURL(found.file);
+        } else {
+          console.log("\u274C No downloadable content found.");
+          if (window.sendEventCallback) {
+            window.sendEventCallback({
+              type: "ERROR",
+              errorMessage: "ErrorCode : 024, No downloadable content found",
+              data: { reason: "No downloadable content found", technicalError: null }
+            });
+          }
+          return;
+        }
+        const a = document.createElement("a");
+        a.href = downloadUrl;
+        a.download = found.name || "document";
+        document.body.appendChild(a);
+        a.click();
+        setTimeout(() => {
+          URL.revokeObjectURL(downloadUrl);
+          a.remove();
+        }, 1e4);
+      };
+    }
+  } catch (err) {
+    console.error("Load failed", err);
+    console.log("\u274C Failed to load documents.");
+    if (window.sendEventCallback) {
+      window.sendEventCallback({
+        type: "ERROR",
+        errorMessage: "ErrorCode : 025, Failed to load documents",
+        data: { reason: "Failed to load documents", technicalError: err }
+      });
+    }
+  }
+}
+window.openDocumentsModal = openDocumentsModal;
+
 // src/__temp_build.js
 async function loadUnviredForms({
   formsData = "formIOComponent",
@@ -353,33 +823,37 @@ async function loadUnviredForms({
   options = {
     nestedFormData: [{}],
     masterData: [{}],
-    title: "the form title entered",
-    descrciption: "the form description entered",
     mode: "",
-    privateExternal: "",
-    permission: "",
     platform: "",
+    permission: "",
     language: "",
+    privateExternal: "",
+    title: "the form title entered",
+    descrciption: "the form description entered",
     translations: {},
-    environmentVariable: [],
     themeData: {},
     userData: {},
-    appData: {},
     controlData: {},
-    showBackButton: false,
-    showMoreButton: true,
     commentsData: [],
     vobArr: [],
+    appData: [],
+    environmentVariable: [],
     formioLibPath: {
       formioPath: "assets/formio.full.min.js"
     },
-    showLoader: true
+    showComments: false,
+    showHelp: false,
+    showBackButton: false,
+    showLoader: true,
+    showMoreButton: true,
+    showCompleteAlways: false,
+    requireCompleteForm: true
   }
 }) {
   var _a, _b;
   let fileKeys = [];
   let formJson;
-  console.log("0000000000", formJson);
+  console.log("data recive step 1", formsData, submissionData, options);
   function sendEventCallback2(params) {
     const eventStructure = sendEventCallback(params);
     if (typeof eventCallback === "function") {
@@ -396,6 +870,7 @@ async function loadUnviredForms({
     });
     return;
   }
+  processDynamicValues(formJson, options.appData);
   const template = formJson;
   const nestedFormArrTemp = options.nestedFormData || [];
   const masterDataArrTemp = options.masterData || [];
@@ -433,13 +908,17 @@ async function loadUnviredForms({
     "masterdata"
   );
   if (submissionData && template) {
-    const r = await validateAttachments(
-      mergedWithMasterData,
-      submissionData,
-      sendEventCallback2
-    );
-    fileKeys = r.fileKeys;
-    if (r.missingFiles.length > 0) {
+    try {
+      const r = await validateAttachments(
+        mergedWithMasterData,
+        submissionData,
+        sendEventCallback2
+      );
+      fileKeys = r.fileKeys;
+      if (r.missingFiles.length > 0) {
+      }
+    } catch (error) {
+      console.warn("Attachment validation skipped:", error);
     }
   }
   if ((options == null ? void 0 : options.appData) && ((_a = Object.keys(options == null ? void 0 : options.appData)) == null ? void 0 : _a.length) > 0) {
@@ -1158,6 +1637,14 @@ body {
   /* subtle shadow for elevation */
 }
 
+
+#submitBtn,
+#saveBtn {
+  width: 110px;
+  display: flex;
+  justify-content: space-evenly;
+}
+
 .form-cmt-btn {
   width: 40px;
   height: 40px;
@@ -1193,8 +1680,9 @@ body {
   width: 100%;
   background-color: #ffffff;
   padding: 6px;
-  justify-content: space-between;
+  justify-content: flex-end;
   align-items: center;
+  gap: 8px;
   border-top: 1px solid #ddd;
   z-index: 1000;
   box-shadow: 0 -2px 6px rgba(0, 0, 0, 0.05);
@@ -1206,18 +1694,20 @@ body {
   display: none;
   position: absolute;
   bottom: 100%;
-  left: 0;
-  margin-bottom: 10px;
+  left: -170px;
+  margin-bottom: 16px;
   background-color: #fff;
   border: 1px solid #ddd;
   box-shadow: 0 2px 8px rgba(0, 0, 0, 0.15);
   padding: 6px;
   border-radius: 6px;
-  z-index: 9999;
+  z-index: 1000;
   flex-direction: column;
   gap: 0px;
 }
 
+#unvired-more-btn {}
+
 /* Print and PDF Modes */
 @media print {
 
@@ -1429,7 +1919,6 @@ body {
 
 @keyframes sdk-pulse {
 
-  0%,
   100% {
     opacity: 1;
   }
@@ -1439,6 +1928,48 @@ body {
   }
 }
 
+/* Responsive Footer for Mobile */
+@media (max-width: 600px) {
+  #sticky-footer {
+    justify-content: flex-end;
+    padding: 4px;
+    gap: 4px;
+  }
+
+  #submitBtn {
+
+    width: 105px;
+    min-width: 108px;
+    flex-grow: 0;
+  }
+
+
+  #saveBtn {
+    width: 80px;
+    min-width: 90px;
+    flex-grow: 0;
+  }
+
+  #unvired-more-btn {
+    margin-left: 10px;
+    margin-right: 10px;
+  }
+
+  /* Fix tooltip on mobile to prevent cutoff */
+  #moreTooltip {
+    position: fixed;
+    bottom: 70px;
+    left: 20px;
+    right: 20px;
+    width: auto;
+    margin-bottom: 0;
+    max-width: 300px;
+    margin-left: auto;
+    margin-right: auto;
+
+  }
+}
+
 /* === STYLE_SEPARATOR === */
 
 .r6o-drawing{cursor:none}.r6o-relations-layer.readonly .handle rect{pointer-events:none}.r6o-relations-layer{position:absolute;top:0;left:0;width:100%;height:100%;pointer-events:none}.r6o-relations-layer circle{stroke:#515151;stroke-width:.4;fill:#3f3f3f}.r6o-relations-layer path{stroke:#595959;stroke-linecap:round;stroke-linejoin:round;fill:transparent}.r6o-relations-layer path.connection{stroke-width:1.6;stroke-dasharray:2,3}.r6o-relations-layer path.r6o-arrow{stroke-width:1.8;fill:#7f7f7f}.r6o-relations-layer .handle rect{stroke-width:1;stroke:#595959;fill:#fff;pointer-events:auto;cursor:pointer}.r6o-relations-layer .handle text{font-size:10px}.r6o-relations-layer .hover{stroke:rgba(63,63,63,.9);stroke-width:1.4;fill:transparent}
@@ -27129,7 +27660,9 @@ select.ui.dropdown {
 /* -----------------
 		Floating label end
 -------------------- */
-`.split("\n\n/* === STYLE_SEPARATOR === */\n\n");
+`.split(
+      "\n\n/* === STYLE_SEPARATOR === */\n\n"
+    );
     cssContents.forEach((cssContent, index) => {
       if (cssContent.trim()) {
         const styleElement = document.createElement("style");
@@ -27201,6 +27734,34 @@ select.ui.dropdown {
         0%, 100% { opacity: 1; }
         50% { opacity: 0.5; }
       }
+      .sdk-loader-back-btn {
+        position: absolute;
+        top: 20px;
+        left: 20px;
+        background: transparent;
+        border: none;
+        color: #333;
+        font-size: 1.2rem;
+        cursor: pointer;
+        padding: 10px;
+        border-radius: 50%;
+        transition: background 0.2s ease;
+        pointer-events: auto;
+        display: flex;
+        align-items: center;
+        justify-content: center;
+        margin: 0;
+        width: 40px;
+        height: 40px;
+      }
+      .sdk-loader-back-btn:hover {
+        background: rgba(0, 0, 0, 0.05);
+        color: #000;
+        border: none;
+      }
+      .sdk-loader-back-btn i {
+        margin: 0;
+      }
     `;
     document.head.appendChild(additionalStyle);
   }
@@ -27229,24 +27790,52 @@ select.ui.dropdown {
       <div id="formio-cmt" style="margin-bottom: 20px;"></div>
     </div>
     <div id="sticky-footer">
+      <button class="ui button primary dataGrid-addRow" id="saveBtn" disabled="true" onclick="FormOnSave()">
+        <i class="icon save large"></i>Save
+      </button>
+      <button class="ui button primary dataGrid-addRow" id="submitBtn" style="display:none" onclick="FormOnSubmit()">
+        <i class="icon save large"></i>Submit
+      </button>
+      
+      <!-- Quick Action Buttons -->
+      <div id="quick-actions" style="display: flex; align-items: center;">
+         <i id="quickCompleteBtn" class="icon clipboard check large" style="display:none; cursor: pointer; margin: 0 10px;" onclick="FormOnSubmit()" title="Complete"></i>
+         <i id="quickSaveBtn" class="icon save large" style="display:none; cursor: pointer; margin: 0 10px;" onclick="FormOnSave()" title="Save"></i>
+         <i id="quickDocumentsBtn" class="icon file alternate large" style="display:none; cursor: pointer; margin: 0 10px;" onclick="openDocumentsModal()" title="Documents"></i>
+         <i id="quickCommentsBtn" class="icon comment large" style="display:none; cursor: pointer; margin: 0 10px;" onclick="loadComments()" title="Comments"></i>
+         <i id="quickHelpBtn" class="icon question circle large" style="display:none; cursor: pointer; margin: 0 10px;" onclick="openHelpLink()" title="Help"></i>
+      </div>
+
       <div class="relative-position">
-        <button id="moreBtn" class="ui button primary dataGrid-addRow" onclick="toggleTooltip()">
-          <i class="icon options"></i>More
+      <button class="ui button primary "  id="unvired-more-btn" onclick="toggleTooltip(event)">
+        <i  class="icon bars large" style="margin: 0;"></i>
         </button>
         <div id="moreTooltip" style="display: none;" class="ui vertical menu">
-          <div class="item">Documents</div>
-          <div class="divider" id="comments-divider" style="display: none;"></div>
+          <div class="item" id="completeOption" onclick="FormOnSubmit()" style="display: none;">Complete</div>
+          <div class="divider"></div>
+          <div class="item" id="saveOption" onclick="FormOnSave()" style="display: none;">Save</div>
+          <div class="divider"></div>
+          <div class="item" id="documentsOption" onclick="openDocumentsModal()" style="display: none;">Documents</div>
+          <div class="divider"></div>
           <div class="item" id="comments-item" style="display: none;" onclick="loadComments()">Comments</div>
           <div class="divider"></div>
-          <div class="item" onclick="openHelpLink()">Help</div>
+          <div class="item"  id="help-item" style="display: none;"  onclick="openHelpLink()">Help</div>
         </div>
       </div>
-      <button class="ui button primary dataGrid-addRow" id="saveBtn" disabled="true" onclick="FormOnSave()">
-        <i class="icon save"></i>Save
-      </button>
-      <button class="ui button primary dataGrid-addRow" id="submitBtn" style="display:none" onclick="FormOnSubmit()">
-        <i class="icon save"></i>Submit
-      </button>
+    </div>
+    <div class="ui modal" id="documentsModal">
+      <i class="close icon"></i>
+      <div class="header">
+        App Documents
+      </div>
+      <div class="content">
+        <div class="ui relaxed divided list" id="documentsList">
+          <div class="item">Loading...</div>
+        </div>
+      </div>
+      <div class="actions">
+        <div class="ui button" onclick="closeDocumentsModal()">Close</div>
+      </div>
     </div>
   `;
   let loaderElement = null;
@@ -27257,23 +27846,48 @@ select.ui.dropdown {
       <div class="sdk-loader-spinner"></div>
       <div class="sdk-loader-text">Loading Form...</div>
       <div class="sdk-loader-subtext">Please wait while we prepare your form</div>
+      <button class="form-back-btn sdk-loader-back-btn" onclick="FormOnBackLoading()">
+        <i class="icon arrow left"></i>
+      </button>
     `;
     container.appendChild(loaderElement);
   }
-  window.toggleTooltip = function() {
+  window.toggleTooltip = function(event) {
+    if (event) {
+      event.stopPropagation();
+    }
     const tooltip = document.getElementById("moreTooltip");
-    const commentsDivider = document.getElementById("comments-divider");
     const commentsItem = document.getElementById("comments-item");
+    const helpItem = document.getElementById("help-item");
+    if (options.showHelp) {
+      helpItem.style.display = "block";
+    } else {
+      helpItem.style.display = "none";
+    }
+    if (options.showComments) {
+      commentsItem.style.display = "block";
+    } else {
+      commentsItem.style.display = "none";
+    }
     if (tooltip.style.display === "none") {
       tooltip.style.display = "flex";
-      setTimeout(() => {
-        commentsDivider.style.display = "";
-        commentsItem.style.display = "";
-      }, 500);
+      tooltip.style.flexDirection = "column";
     } else {
       tooltip.style.display = "none";
-      commentsDivider.style.display = "none";
-      commentsItem.style.display = "none";
+      return;
+    }
+    const items = Array.from(tooltip.querySelectorAll(".item"));
+    const dividers = Array.from(tooltip.querySelectorAll(".divider"));
+    dividers.forEach((d) => d.style.display = "none");
+    const visibleItems = items.filter((item) => {
+      return item.style.display !== "none" && item.offsetParent !== null;
+    }).filter((item) => item.style.display !== "none");
+    for (let i = 0; i < visibleItems.length - 1; i++) {
+      const item = visibleItems[i];
+      let next = item.nextElementSibling;
+      if (next && next.classList.contains("divider")) {
+        next.style.display = "block";
+      }
     }
   };
   window.openHelpLink = function() {
@@ -27288,36 +27902,46 @@ select.ui.dropdown {
     }
   };
   document.addEventListener("click", function(event) {
-    const moreBtn2 = document.getElementById("moreBtn");
+    const moreBtn2 = document.getElementById("unvired-more-btn");
     const tooltip = document.getElementById("moreTooltip");
     if (moreBtn2 && tooltip && !moreBtn2.contains(event.target) && !tooltip.contains(event.target)) {
       tooltip.style.display = "none";
     }
   });
-  window.loadComments = function() {
+  window.loadComments = window.loadComments || function() {
     if (typeof window.loadCommentsFunction === "function") {
       window.loadCommentsFunction();
     }
   };
-  window.FormOnBack = function() {
+  window.FormOnBack = window.FormOnBack || function() {
     sendEventCallback2({ type: "FORM_BACK_NAVIGATION" });
   };
-  window.CommentOnBack = function() {
+  window.FormOnBackLoading = window.FormOnBackLoading || function() {
+    console.log("Back button clicked during loading, canceling form load");
+    if (loaderElement) {
+      loaderElement.classList.add("hidden");
+      if (loaderElement.parentNode) {
+        loaderElement.parentNode.removeChild(loaderElement);
+      }
+    }
+    sendEventCallback2({ type: "FORM_BACK_NAVIGATION" });
+  };
+  window.CommentOnBack = window.CommentOnBack || function() {
     if (typeof window.commentOnBackFunction === "function") {
       window.commentOnBackFunction();
     }
   };
-  window.submitComments = function() {
+  window.submitComments = window.submitComments || function() {
     if (typeof window.submitCommentsFunction === "function") {
       window.submitCommentsFunction();
     }
   };
-  window.FormOnSave = function() {
+  window.FormOnSave = window.FormOnSave || function() {
     if (typeof window.formOnSaveFunction === "function") {
       window.formOnSaveFunction();
     }
   };
-  window.FormOnSubmit = function() {
+  window.FormOnSubmit = window.FormOnSubmit || function() {
     if (typeof window.formOnSubmitFunction === "function") {
       window.formOnSubmitFunction();
     }
@@ -48239,6 +48863,14 @@ async function startCameraScanner() {
 
     showBarcodeError(errorMessage);
     setTimeout(() => closeScannerModal(), 3000);
+
+    if (window.sendEventCallback) {
+      window.sendEventCallback({
+        type: "ERROR",
+        errorMessage: "ErrorCode : 012, Camera access error",
+        data: { technicalError: err, reason: errorMessage }
+      });
+    }
   }
 }
 
@@ -48622,7 +49254,7 @@ function injectBarcodeModalStyles() {
 
 (function(){
 // Listen for "getLocation" custom event
-  document.addEventListener("getLocation", function (event) {
+document.addEventListener("getLocation", function (event) {
   const { compObj, controlId } = event.detail;
   window.compId = controlId;
   getLocationFromBrowser(controlId); // Pass controlId to getLocationFromBrowser
@@ -48632,7 +49264,7 @@ function injectBarcodeModalStyles() {
 function getLocationFromBrowser(componentID) {
   // Check if running in Cordova environment
   const isCordova = !!(window.cordova || window.PhoneGap || window.phonegap);
-  
+
   if (!navigator.geolocation) {
     showLocationError("Geolocation is not supported by this device.");
     return;
@@ -48653,7 +49285,7 @@ function getLocationFromBrowser(componentID) {
           showLocationError("Location permission was denied. Please enable it in browser settings and refresh the page.");
           return;
         }
-        
+
         if (permissionStatus.state === "granted" || permissionStatus.state === "prompt") {
           requestLocation(componentID);
         }
@@ -48671,7 +49303,7 @@ function getLocationFromBrowser(componentID) {
 
 function requestLocation(componentID) {
   const isCordova = !!(window.cordova || window.PhoneGap || window.phonegap);
-  
+
   const options = {
     enableHighAccuracy: true,
     timeout: isCordova ? 30000 : 10000, // Longer timeout for Cordova
@@ -48688,7 +49320,7 @@ function requestLocation(componentID) {
         },
       });
       document.dispatchEvent(customEvent);
-      
+
       // Send success event
       if (window.sendEventCallback) {
         window.sendEventCallback({
@@ -48706,36 +49338,36 @@ function requestLocation(componentID) {
 }
 
 function handleLocationError(error) {
-  let errorMessage = "Unable to retrieve location";
-  let errorCode = "008";
-  
+  let errorMessage = "Location unknown error";
+  let errorCode = "011";
+
   switch (error.code) {
     case error.PERMISSION_DENIED:
-      errorMessage = "Location permission denied. Please allow location access and try again.";
+      errorMessage = "Location permission denied";
       errorCode = "008";
       break;
     case error.POSITION_UNAVAILABLE:
-      errorMessage = "Location information is unavailable. Please check your GPS settings.";
+      errorMessage = "Location unavailable";
       errorCode = "009";
       break;
     case error.TIMEOUT:
-      errorMessage = "Location request timed out. Please try again.";
+      errorMessage = "Location request timeout";
       errorCode = "010";
       break;
     default:
-      errorMessage = "An unknown error occurred while retrieving location.";
+      errorMessage = "Location unknown error";
       errorCode = "011";
       break;
   }
-  
+
   showLocationError(errorMessage);
   console.error("Geolocation error:", error);
-  
+
   // Send error event
   if (window.sendEventCallback) {
     window.sendEventCallback({
       type: "ERROR",
-  errorMessage: \`ErrorCode : \${errorCode}, Location error. Contact your admin or tech team.\`,
+      errorMessage: \`ErrorCode : \${errorCode}, \${errorMessage}\`,
       data: { technicalError: error, reason: errorMessage }
     });
   }
@@ -48760,9 +49392,9 @@ function showLocationError(message) {
     text-align: center;
   \`;
   errorDiv.textContent = message;
-  
+
   document.body.appendChild(errorDiv);
-  
+
   // Remove after 5 seconds
   setTimeout(() => {
     if (errorDiv.parentNode) {
@@ -48805,15 +49437,18 @@ let capturedImageData = "";
 function openCameraModal() {
   injectCameraModalStyles();
 
+  // Ensure clean slate: Remove any existing modal if present
   const existingModal = document.getElementById("cameraModal");
+  if (existingModal) {
+    existingModal.remove();
+  }
 
   capturedImageData = "";
 
-  if (!existingModal) {
-    const modalHTML = \`
+  const modalHTML = \`
   <div id="cameraModal">
     <div id="cameraContainer">
-      <video id="cameraVideo" autoplay playsinline style="opacity: 0;"></video>
+      <video id="cameraVideo" playsinline webkit-playsinline muted style="opacity: 0; pointer-events: none;"></video>
       <div id="cameraLoader">
         <div class="loader-spinner"></div>
         <p class="loader-text">Starting camera...</p>
@@ -48824,6 +49459,11 @@ function openCameraModal() {
             <path d="M18 6L6 18M6 6L18 18" stroke="white" stroke-width="2" stroke-linecap="round"/>
           </svg>
         </button>
+        <div class="camera-select-container">
+          <select id="cameraSelect" class="camera-select">
+            <option value="" disabled selected>Select Camera</option>
+          </select>
+        </div>
         <div id="captureButton" style="opacity: 0; pointer-events: none;">
           <div class="capture-ring">
             <div class="capture-inner"></div>
@@ -48833,35 +49473,18 @@ function openCameraModal() {
     </div>
   </div>
 \`;
-    document.body.insertAdjacentHTML("beforeend", modalHTML);
-    document.getElementById("closeCameraBtn").addEventListener("click", closeCameraModal);
-    document.getElementById("captureButton").addEventListener("click", captureImage);
-  } else {
-    existingModal.style.display = "block";
-
-    // Reset UI state when reopening
-    const video = document.getElementById("cameraVideo");
-    const loader = document.getElementById("cameraLoader");
-    const captureBtn = document.getElementById("captureButton");
-
-    if (video) {
-      video.style.opacity = "0";
-      video.srcObject = null;
-    }
-    if (loader) {
-      loader.style.display = "flex";
-      loader.style.opacity = "1";
-    }
-    if (captureBtn) {
-      captureBtn.style.opacity = "0";
-      captureBtn.style.pointerEvents = "none";
-    }
-  }
+  document.body.insertAdjacentHTML("beforeend", modalHTML);
+  document.getElementById("closeCameraBtn").addEventListener("click", closeCameraModal);
+  document.getElementById("captureButton").addEventListener("click", captureImage);
+  document.getElementById("cameraSelect").addEventListener("change", (e) => {
+    startCameraStream(e.target.value);
+  });
 
+  // Small delay to ensure DOM is ready
   setTimeout(startCameraStream, 100);
 }
 
-async function startCameraStream() {
+async function startCameraStream(deviceId = null) {
   if (videoStream) {
     try {
       videoStream.getTracks().forEach(track => track.stop());
@@ -48872,42 +49495,84 @@ async function startCameraStream() {
   }
 
   try {
+    const isIOS = /iPad|iPhone|iPod/.test(navigator.userAgent) || (window.platform && window.platform.iosPlatform);
+
+    // Check if API is supported
+    if (!navigator.mediaDevices || !navigator.mediaDevices.getUserMedia) {
+      const errorMsg = "Camera API is not supported. Please ensure you are using HTTPS or localhost.";
+      alert(errorMsg);
+      showCameraError(errorMsg);
+      return;
+    }
+
     const video = document.getElementById("cameraVideo");
     if (!video) {
       alert("Camera video element not found.");
       return;
     }
 
-    // Get available cameras
-    const devices = await navigator.mediaDevices.enumerateDevices();
-    const videoDevices = devices.filter(device => device.kind === 'videoinput');
+    // Simplified approach: Ask for camera directly. 
+    // This allows the browser to handle permissions correctly on all platforms (Windows/Android/iOS)
+    // and defaults to the system default camera (webcam) on laptops.
+    // Simplified approach: Ask for camera directly.
+    // We race against a timeout because WebViews often hang indefinitely if permissions aren't handled.
+    // OPTIMIZATION: Request 16:9 aspect ratio (1280x720) instead of 4:3 (640x480).
+    // This reduces the "zoom" effect on modern mobile screens which are typically 16:9 or taller.
+    const constraints = {
+      video: {
+        width: { ideal: 1280 },
+        height: { ideal: 720 }
+      }
+    };
 
-    if (!videoDevices.length) {
-      alert("No camera devices found.");
-      return;
+    if (deviceId) {
+      constraints.video.deviceId = { exact: deviceId };
+    } else {
+      constraints.video.facingMode = "environment";
     }
 
-    // Prefer back camera
-    const backCamera = videoDevices.find(device =>
-      device.label.toLowerCase().includes('back') ||
-      device.label.toLowerCase().includes('rear')
-    ) || videoDevices[0];
+    const streamPromise = navigator.mediaDevices.getUserMedia(constraints);
 
-    videoStream = await navigator.mediaDevices.getUserMedia({
-      video: {
-        deviceId: backCamera.deviceId,
-        facingMode: "environment",
-        width: { ideal: 640 },
-        height: { ideal: 480 }
+    const timeoutPromise = new Promise((_, reject) =>
+      setTimeout(() => reject(new Error("PermissionTimeout")), 6000)
+    );
+
+    try {
+      videoStream = await Promise.race([streamPromise, timeoutPromise]);
+    } catch (err) {
+      if (err.message === "PermissionTimeout") {
+        throw new Error("Permission request timed out. Please check app permissions.");
       }
-    });
+      throw err;
+    }
 
+    // iOS Specific: Ensure inline playback setup BEFORE stream assignment
+    if (isIOS) {
+      video.setAttribute("playsinline", "");
+      video.setAttribute("webkit-playsinline", "");
+      video.playsInline = true; // Set property as well
+    }
+
+    // Mute video to prevent audio feedback and allow autoplay in restrictive policies
+    video.muted = true;
+
+    // Assign stream
     video.srcObject = videoStream;
 
+    // Ensure video doesn't stay paused if it somehow exits fullscreen or gets interrupted
+    video.onpause = () => {
+      if (cameraStarted && video.srcObject) {
+        // Only try to resume if we expect it to be playing
+        video.play().catch(e => console.log("Resume error", e));
+      }
+    };
+
     // Wait for video to start playing, then hide loader
     video.onloadedmetadata = () => {
-      video.play().then(() => {
-        // Hide loader and show camera UI
+      // Once permission is granted and stream starts, listing devices will return labels
+      populateCameraDevices();
+
+      const showUI = () => {
         const loader = document.getElementById("cameraLoader");
         const captureBtn = document.getElementById("captureButton");
 
@@ -48915,23 +49580,34 @@ async function startCameraStream() {
           loader.style.display = "none";
           loader.style.opacity = "0";
         }
+
         video.style.opacity = "1";
+
         if (captureBtn) {
           captureBtn.style.opacity = "1";
           captureBtn.style.pointerEvents = "all";
         }
+      };
 
+      video.play().then(() => {
+        showUI();
         cameraStarted = true;
       }).catch(err => {
         console.error("Video play error:", err);
-        alert("Failed to start video: " + err.message);
-        closeCameraModal();
+        if (!video.paused) {
+          console.log("Video is playing despite error. Continuing.");
+          showUI();
+          cameraStarted = true;
+        } else {
+          alert("Failed to start video preview: " + err.message);
+          closeCameraModal();
+        }
       });
     };
 
   } catch (err) {
     console.error("Camera start error:", err);
-    let errorMessage = "Failed to start camera";
+    let errorMessage = err.message || "Failed to start camera";
 
     if (err.name === 'NotAllowedError' || err.name === 'PermissionDeniedError') {
       errorMessage = "Camera permission denied. Please allow camera access and try again.";
@@ -48947,18 +49623,50 @@ async function startCameraStream() {
       errorMessage = "Camera access was interrupted.";
     }
 
-    showCameraError(errorMessage);
+    alert(errorMessage);
+    closeCameraModal();
+  }
+}
+
+async function populateCameraDevices() {
+  const select = document.getElementById("cameraSelect");
+  if (!select) return;
 
-    // Send error event
-    if (window.sendEventCallback) {
-      window.sendEventCallback({
-        type: "ERROR",
-        errorMessage: "ErrorCode : 012, Camera access error. Contact your admin or tech team.",
-        data: { technicalError: err, reason: errorMessage }
+  try {
+    const devices = await navigator.mediaDevices.enumerateDevices();
+    const videoDevices = devices.filter(device => device.kind === 'videoinput');
+
+    // Only show if we have more than 1 camera, or at least we want to show the current one
+    if (videoDevices.length > 0) {
+      select.innerHTML = '<option value="" disabled>Select Camera</option>';
+
+      let currentDeviceId = "";
+      if (videoStream) {
+        const track = videoStream.getVideoTracks()[0];
+        if (track) {
+          const settings = track.getSettings();
+          currentDeviceId = settings.deviceId;
+        }
+      }
+
+      videoDevices.forEach((device, index) => {
+        const option = document.createElement("option");
+        option.value = device.deviceId;
+        option.text = device.label || \`Camera \${index + 1}\`;
+        if (device.deviceId === currentDeviceId) {
+          option.selected = true;
+        }
+        select.appendChild(option);
       });
-    }
 
-    setTimeout(() => closeCameraModal(), 3000);
+      // If there are multiple devices, ensure the dropdown container is visible
+      const container = document.querySelector('.camera-select-container');
+      if (container) {
+        container.style.display = videoDevices.length > 1 ? 'block' : 'none';
+      }
+    }
+  } catch (e) {
+    console.warn("Error enumerating devices:", e);
   }
 }
 
@@ -49028,19 +49736,19 @@ function closeCameraModal() {
   const modal = document.getElementById("cameraModal");
 
   if (videoStream) {
-    videoStream.getTracks().forEach(track => track.stop());
+    try {
+      videoStream.getTracks().forEach(track => track.stop());
+    } catch (e) {
+      console.warn("Error stopping tracks", e);
+    }
     videoStream = null;
     cameraStarted = false;
   }
 
-  // Reset video element
-  const video = document.getElementById("cameraVideo");
-  if (video) {
-    video.srcObject = null;
-    video.style.opacity = "0";
+  // Completely remove from DOM to reset video element state for iOS
+  if (modal) {
+    modal.remove();
   }
-
-  if (modal) modal.style.display = "none";
 }
 
 function injectCameraModalStyles() {
@@ -49071,6 +49779,7 @@ function injectCameraModalStyles() {
       object-fit: cover;
       background: #000;
       transition: opacity 0.3s ease;
+      pointer-events: none;
     }
 
     #cameraLoader {
@@ -49151,6 +49860,39 @@ function injectCameraModalStyles() {
       background: rgba(0, 0, 0, 0.7);
     }
 
+    .camera-select-container {
+        position: absolute;
+        top: 20px;
+        right: 20px;
+        z-index: 10001;
+        pointer-events: all;
+        display: none; /* Hidden by default until devices found */
+    }
+
+    .camera-select {
+        background: rgba(0, 0, 0, 0.5);
+        color: white;
+        border: 1px solid rgba(255, 255, 255, 0.3);
+        padding: 8px 12px;
+        border-radius: 20px;
+        font-size: 14px;
+        backdrop-filter: blur(10px);
+        outline: none;
+        cursor: pointer;
+        appearance: none;
+        -webkit-appearance: none;
+        padding-right: 30px;
+        background-image: url("data:image/svg+xml;charset=US-ASCII,%3Csvg%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20width%3D%22292.4%22%20height%3D%22292.4%22%3E%3Cpath%20fill%3D%22%23FFFFFF%22%20d%3D%22M287%2069.4a17.6%2017.6%200%200%200-13-5.4H18.4c-5%200-9.3%201.8-12.9%205.4A17.6%2017.6%200%200%200%200%2082.2c0%205%201.8%209.3%205.4%2012.9l128%20127.9c3.6%203.6%207.8%205.4%2012.8%205.4s9.2-1.8%2012.8-5.4L287%2095c3.5-3.5%205.4-7.8%205.4-12.8%200-5-1.9-9.2-5.5-12.8z%22%2F%3E%3C%2Fsvg%3E");
+        background-repeat: no-repeat;
+        background-position: right 10px center;
+        background-size: 10px;
+    }
+
+    .camera-select option {
+        background: #333;
+        color: white;
+    }
+
     #captureButton {
       position: absolute;
       bottom: 40px;
@@ -49217,6 +49959,11 @@ function injectCameraModalStyles() {
         bottom: env(safe-area-inset-bottom, 40px);
         bottom: max(40px, env(safe-area-inset-bottom));
       }
+
+      .camera-select-container {
+        top: env(safe-area-inset-top, 20px);
+        top: max(20px, env(safe-area-inset-top));
+      }
     }
 
     /* Landscape mode adjustments */
@@ -49851,7 +50598,7 @@ see README and LICENSE for details
 
 let flag = false;
 class SmartStorage {
-  constructor() {}
+  constructor() { }
 
   static get title() {
     return "SmartStorage";
@@ -49877,15 +50624,38 @@ class SmartStorage {
 
     return new Promise((resolve, reject) => {
       const request = indexedDB.open("Forms-Attachments", 3);
+
       request.onsuccess = function (event) {
         const db = event.target.result;
+        if (!db.objectStoreNames.contains("Files")) {
+          console.warn("[SmartStorage] Files store missing. Recreating database.");
+          db.close();
+          const deleteReq = indexedDB.deleteDatabase("Forms-Attachments");
+          deleteReq.onsuccess = () => {
+            const retryReq = indexedDB.open("Forms-Attachments", 3);
+            retryReq.onupgradeneeded = (e) => {
+              const newDb = e.target.result;
+              newDb.createObjectStore("Files");
+            };
+            retryReq.onsuccess = (e) => resolve(e.target.result);
+            retryReq.onerror = (e) => reject(e);
+          };
+          deleteReq.onerror = (e) => reject(e);
+          return;
+        }
         resolve(db);
       };
 
       request.onupgradeneeded = function (e) {
         const db = e.target.result;
-        db.createObjectStore("Files");
-        resolve(db);
+        if (!db.objectStoreNames.contains("Files")) {
+          db.createObjectStore("Files");
+        }
+        resolve(db); // Note: resolve here calls with incomplete db during upgrade transaction, but it's typically fine for callers waiting on db handle. 
+        // Ideally we resolve in onsuccess, but existing code had it this way too? 
+        // Actually, in the original code, it resolved in BOTH. Resolving in upgrade gives the transaction-bound db.
+        // But Standard practice is waiting for success.
+        // The original code had \`resolve(db)\` in \`onupgradeneeded\`.
       };
 
       request.onerror = function (e) {
@@ -49912,6 +50682,7 @@ class SmartStorage {
           size: file.size,
           type: file.type,
           url,
+          mode: "A",
         };
         if (
           window.platform.isBrowser ||
@@ -49933,6 +50704,7 @@ class SmartStorage {
               type: file.type,
               url: url,
               id,
+              mode: "A",
             });
           };
         } else {
@@ -49943,6 +50715,7 @@ class SmartStorage {
             type: file.type,
             url: url,
             id,
+            mode: "A",
           });
         }
       };
@@ -50029,6 +50802,7 @@ class SmartStorage {
               size: blobObject.size,
               type: file.type,
               url: file.url,
+              mode: file.mode || "G",
             };
             const trans = db.transaction(["Files"], "readwrite");
             const addReq = trans.objectStore("Files").put(data, id);
@@ -50688,7 +51462,21 @@ class SmartFileComponent extends FieldComponent {
   }
 
   getValue() {
-    return this.dataValue;
+    const value = Array.isArray(this.dataValue) ? this.dataValue : (this.dataValue ? [this.dataValue] : []);
+    return value.concat(this.deletedFiles || []);
+  }
+
+  setValue(value, flags) {
+    if (Array.isArray(value)) {
+      this.deletedFiles = value.filter(f => f.mode === 'D');
+      value = value.filter(f => f.mode !== 'D');
+    } else if (value && value.mode === 'D') {
+      this.deletedFiles = [value];
+      value = [];
+    } else {
+      this.deletedFiles = [];
+    }
+    return super.setValue(value, flags);
   }
 
   get defaultValue() {
@@ -51011,6 +51799,13 @@ class SmartFileComponent extends FieldComponent {
         new SmartStorage().markFileAsDeleted(fileInfo.id);
         this.deleteFile(fileInfo);
         event.preventDefault();
+
+        fileInfo.mode = "D";
+        if (!this.deletedFiles) {
+          this.deletedFiles = [];
+        }
+        this.deletedFiles.push(fileInfo);
+
         this.splice(index);
         this.redraw();
       });
@@ -51265,10 +52060,8 @@ class SmartFileComponent extends FieldComponent {
         let id = this.component.id;
         isfileBrowse = false;
 
-        // let isbrowser = (!document.URL.startsWith('http:') || document.URL.startsWith('http://localhost:8000'))
-        // if (window.platform.isAndroid && !isbrowser) {
-
-        if (window.platform.isAndroid) {
+        // Dispatch custom camera event for both Android and iOS
+        if (window.platform.isAndroid || window.platform.iosPlatform) {
           window.isListenerSet = false;
           let eventCustom = new CustomEvent("openCamera", {
             detail: {
@@ -51652,6 +52445,24 @@ class SmartFileComponent extends FieldComponent {
     if (this.component.storage && files && files.length) {
       // if (this.component.storage && files) {
       Array.prototype.forEach.call(files, async (file) => {
+        // Modify iOS filenames with timestamp BEFORE duplicate check
+        let originalFileName = file.name;
+        if (window.platform.iosPlatform) {
+          const fileNameOriginal = file.name;
+          const lastDotIndex = fileNameOriginal.lastIndexOf(".");
+          let newName = "";
+          if (lastDotIndex !== -1) {
+            newName = \`\${fileNameOriginal.substring(
+              0,
+              lastDotIndex
+            )}-\${Date.now()}\${fileNameOriginal.substring(lastDotIndex)}\`;
+          } else {
+            newName = \`\${fileNameOriginal}-\${Date.now()}\`;
+          }
+          file = new File([file], newName, {
+            type: file.type,
+          });
+        }
         const fileName = uniqueName(
           file.name,
           this.component.fileNameTemplate,
@@ -51694,8 +52505,9 @@ class SmartFileComponent extends FieldComponent {
         // Check if file with the same name is being uploaded
         var fileWithSameNameUploaded = false;
         if (window.platform.iosPlatform) {
+          // For iOS, compare using the escaped filename (after timestamp modification)
           fileWithSameNameUploaded = this.dataValue.some(
-            (fileStatus) => fileStatus.url === imagUrl
+            (fileStatus) => fileStatus.originalName === escapedFileName
           );
         } else {
           fileWithSameNameUploaded = isfileBrowse
@@ -51905,19 +52717,27 @@ class SmartFileComponent extends FieldComponent {
               fileInfo.originalName = escapedFileName;
               fileInfo.hash = fileUpload.hash;
               fileInfo.compnentId = this.component.id;
+              fileInfo.mode = fileUpload.mode || "A";
               if (!this.hasValue()) {
                 this.dataValue = [];
               }
               if (replace) {
-                let ind;
+                let ind = -1;
                 for (let i = 0; i < this.dataValue.length; i++) {
                   if (this.dataValue[i].originalName == fileInfo.originalName) {
                     console.log("original name matches");
                     ind = i;
+                    break;
                   }
                 }
                 if (ind !== -1) {
                   let originalFileId = this.dataValue[ind].id;
+                  let originalFileMode = this.dataValue[ind].mode;
+
+                  if (originalFileMode === "G" || originalFileMode === "M") {
+                    fileInfo.mode = "M";
+                  }
+
                   console.log("originalFileId = " + originalFileId);
                   this.dataValue[ind] = fileInfo;
                   let eventCustom = new CustomEvent(
@@ -59464,7 +60284,7 @@ class SmartSelectComponent extends SmartSelectField {
     return {
       ...super.conditionOperatorsSettings,
       valueComponent(classComp) {
-        const valueComp = { ... classComp, type: 'select' };
+        const valueComp = { ...classComp, type: 'select' };
 
         if (isSelectResourceWithObjectValue(classComp)) {
           valueComp.reference = false;
@@ -59616,7 +60436,7 @@ class SmartSelectComponent extends SmartSelectField {
       return this.component.valueProperty;
     }
     // Force values datasource to use values without actually setting it on the component settings.
-   if(this.component.dataSrc === 'values') {
+    if (this.component.dataSrc === 'values') {
       return 'value';
     }
     return '';
@@ -59654,10 +60474,10 @@ class SmartSelectComponent extends SmartSelectField {
 
   get shouldInitialLoad() {
     if (this.component.widget === 'html5' &&
-        this.isEntireObjectDisplay() &&
-        this.component.searchField &&
-        this.dataValue) {
-          return false;
+      this.isEntireObjectDisplay() &&
+      this.component.searchField &&
+      this.dataValue) {
+      return false;
     }
 
     return super.shouldLoad;
@@ -59692,7 +60512,7 @@ class SmartSelectComponent extends SmartSelectField {
     if (this.component.multiple && _.isArray(this.dataValue) ? this.dataValue.find((val) => value === val) : (this.dataValue === value)) {
       const selectData = this.selectData;
       if (selectData) {
-        const templateValue = this.component.reference && value && (value._id  ? value._id.toString() : value);
+        const templateValue = this.component.reference && value && (value._id ? value._id.toString() : value);
         if (!this.templateData || !this.templateData[templateValue]) {
           this.getOptionTemplate(data, value);
         }
@@ -59719,7 +60539,7 @@ class SmartSelectComponent extends SmartSelectField {
       });
     }
 
-   if (data.data) {
+    if (data.data) {
       // checking additional fields in the template for the selected Entire Object option
       const hasNestedFields = /item\\.data\\.\\w*/g.test(this.component.template);
       data.data = this.isEntireObjectDisplay() && _.isObject(data.data) && !hasNestedFields ?
@@ -59738,8 +60558,8 @@ class SmartSelectComponent extends SmartSelectField {
         hasTranslator = this.i18next.translator;
       }
       if (!label || (hasTranslator && !this.t(label, {
-          _userInput: true
-        }))) return;
+        _userInput: true
+      }))) return;
       return hasTranslator ? template.replace(label, this.t(label, {
         _userInput: true
       })) : label;
@@ -59766,7 +60586,7 @@ class SmartSelectComponent extends SmartSelectField {
     //   ...idPath
     // };
 
-     const option = Object.assign({
+    const option = Object.assign({
       value: this.getOptionValue(value),
       label,
     }, idPath);
@@ -59922,7 +60742,7 @@ class SmartSelectComponent extends SmartSelectField {
       if (this.root && this.root.options.editForm && this.root.options.editForm._id && this.root.options.editForm._id === item._id) return;
       const itemValueAndLabel = this.selectValueAndLabel(item);
       this.addOption(itemValueAndLabel.value, itemValueAndLabel.label, {}, _.get(item, this.component.idPath, String(index)));
-   
+
     });
     if (this.choices) {
       if ((this.component.dataSrc === 'masterdata') && this.component.masterdata) {
@@ -59964,10 +60784,10 @@ class SmartSelectComponent extends SmartSelectField {
       // If a value is provided, then select it.
       if (!this.isEmpty()) {
         if (localStorage.getItem('renderMode') === 'html') {
-        var tmplt = this.component.template;
-        var str1 = tmplt.substring(tmplt.lastIndexOf('.') + 1, tmplt.length);
-        var label = str1.substring(0, str1.indexOf('}'), str1.length);
-        label = label.trim();
+          var tmplt = this.component.template;
+          var str1 = tmplt.substring(tmplt.lastIndexOf('.') + 1, tmplt.length);
+          var label = str1.substring(0, str1.indexOf('}'), str1.length);
+          label = label.trim();
 
           if (items.length > 0) {
             if (this.component.multiple) {
@@ -59980,13 +60800,13 @@ class SmartSelectComponent extends SmartSelectField {
               });
             } else {
             }
+          }
+        } else {
+          this.setValue(this.dataValue, {
+            noUpdateEvent: true
+          });
         }
-      }else{
-        this.setValue(this.dataValue, {
-          noUpdateEvent: true
-        });
-      }
-      }else if (this.shouldAddDefaultValue && !this.options.readOnly) {
+      } else if (this.shouldAddDefaultValue && !this.options.readOnly) {
         // If a default value is provided then select it.
         const defaultValue = this.defaultValue;
         if (!this.isEmpty(defaultValue)) {
@@ -60293,32 +61113,32 @@ class SmartSelectComponent extends SmartSelectField {
           } else {
             if (!this.component.dropdownOpened && this.data[this.key] && String(this.data[this.key]).length > 0) {
               let result = [];
-              if(this.component.multiple && this.component.masterdata){
-                this.data[this.key].forEach(item => 
+              if (this.component.multiple && this.component.masterdata) {
+                this.data[this.key].forEach(item =>
                   this.component.masterdata.filter((value) => {
                     const propValue = value[this.component.valueProperty];
-                  // Convert to string only if necessary
-                  const valPropData = typeof propValue !== 'string' ? String(propValue) : propValue;
-                    if(valPropData.includes(item)){
+                    // Convert to string only if necessary
+                    const valPropData = typeof propValue !== 'string' ? String(propValue) : propValue;
+                    if (valPropData.includes(item)) {
                       result.push(value)
                     }
                   })
                 );
                 // result = this.component.masterdata;
-              }else{
-                if(this.component.masterdata){
-                 result = this.component.masterdata.filter(value => {
-                  const propValue = value[this.component.valueProperty];
-                  // Convert to string only if necessary
-                  const valPropData = typeof propValue !== 'string' ? String(propValue) : propValue;
-                  return valPropData?.includes(this.data[this.key]);
-                });
-              }
+              } else {
+                if (this.component.masterdata) {
+                  result = this.component.masterdata.filter(value => {
+                    const propValue = value[this.component.valueProperty];
+                    // Convert to string only if necessary
+                    const valPropData = typeof propValue !== 'string' ? String(propValue) : propValue;
+                    return valPropData?.includes(this.data[this.key]);
+                  });
+                }
               }
               const unique = result.filter((obj, index) => {
                 return index === result.findIndex(o => obj[this.component.valueProperty] === o[this.component.valueProperty]);
-            });
-               this.setItems(unique);
+              });
+              this.setItems(unique);
             }
           }
         }
@@ -60479,9 +61299,9 @@ class SmartSelectComponent extends SmartSelectField {
   get active() {
     if ((this.component.dataSrc === 'masterdata') && this.component.masterdata) {
       return !this.component.lazyLoad || this.activated;
-    }else{
-    // return !this.component.lazyLoad || this.activated || this.options.readOnly;
-    return !this.component.lazyLoad || this.activated;
+    } else {
+      // return !this.component.lazyLoad || this.activated || this.options.readOnly;
+      return !this.component.lazyLoad || this.activated;
     }
   }
 
@@ -60555,8 +61375,8 @@ class SmartSelectComponent extends SmartSelectField {
       searchChoices: !this.component.searchField,
       searchFields: _.get(this, 'component.searchFields', ['label']),
       shadowRoot: this.root ? this.root.shadowRoot : null,
-    fuseOptions: this.component.useExactSearch ? Object.assign(fuseObj, commonFuseOptions) : Object.assign({},
-        _.get(this, 'component.fuseOptions', {}), 
+      fuseOptions: this.component.useExactSearch ? Object.assign(fuseObj, commonFuseOptions) : Object.assign({},
+        _.get(this, 'component.fuseOptions', {}),
         Object.assign(fuseObj1, commonFuseOptions)
       ),
       valueComparer: _.isEqual,
@@ -60724,17 +61544,17 @@ class SmartSelectComponent extends SmartSelectField {
         }
         this.isFromSearch = false;
       });
-         // avoid spamming the resource/url endpoint when we have server side filtering enabled.
-         const debounceTimeout = this.component.searchField && (this.isSelectResource || this.isSelectURL) ?
-         (this.component.searchDebounce === 0 ? 0 : this.component.searchDebounce || this.defaultSchema.searchDebounce) * 1000
-         : 0;
-         const updateComponent = (evt) => {
-           this.triggerUpdate(evt.detail.value);
-         };
-         this.addEventListener(input, 'search', _.debounce((e) => {
-          updateComponent(e);
-          this.positionDropdown();
-        },  debounceTimeout));
+      // avoid spamming the resource/url endpoint when we have server side filtering enabled.
+      const debounceTimeout = this.component.searchField && (this.isSelectResource || this.isSelectURL) ?
+        (this.component.searchDebounce === 0 ? 0 : this.component.searchDebounce || this.defaultSchema.searchDebounce) * 1000
+        : 0;
+      const updateComponent = (evt) => {
+        this.triggerUpdate(evt.detail.value);
+      };
+      this.addEventListener(input, 'search', _.debounce((e) => {
+        updateComponent(e);
+        this.positionDropdown();
+      }, debounceTimeout));
 
       this.addEventListener(input, 'stopSearch', () => this.triggerUpdate());
       this.addEventListener(input, 'hideDropdown', () => {
@@ -60749,9 +61569,9 @@ class SmartSelectComponent extends SmartSelectField {
           if (this.data[this.key] && String(this.data[this.key]).length > 0) {
             selData = this.component.masterdata.filter((value) => {
               const propValue = value[this.component.valueProperty];
-                  // Convert to string only if necessary
-                  const valPropData = typeof propValue !== 'string' ? String(propValue) : propValue;
-                  return valPropData?.includes(this.data[this.key]);
+              // Convert to string only if necessary
+              const valPropData = typeof propValue !== 'string' ? String(propValue) : propValue;
+              return valPropData?.includes(this.data[this.key]);
 
             })
           }
@@ -60844,10 +61664,10 @@ class SmartSelectComponent extends SmartSelectField {
   setDropdownPosition() {
     let dropdown;
     let container;
-    if(this.choices && this.choices.dropdown && this.choices.dropdown.element){
-    dropdown = this.choices.dropdown.element;
+    if (this.choices && this.choices.dropdown && this.choices.dropdown.element) {
+      dropdown = this.choices.dropdown.element;
     }
-    if(this.choices && this.choices.containerOuter && this.choices.containerOuter.element){
+    if (this.choices && this.choices.containerOuter && this.choices.containerOuter.element) {
       container = this.choices.containerOuter.element;
     }
 
@@ -60932,9 +61752,9 @@ class SmartSelectComponent extends SmartSelectField {
       if (this.data[this.key] && String(this.data[this.key]).length > 0) {
         selData = this.component.masterdata.filter((value) => {
           const propValue = value[this.component.valueProperty];
-                  // Convert to string only if necessary
-                  const valPropData = typeof propValue !== 'string' ? String(propValue) : propValue;
-                  return valPropData?.includes(this.data[this.key]);
+          // Convert to string only if necessary
+          const valPropData = typeof propValue !== 'string' ? String(propValue) : propValue;
+          return valPropData?.includes(this.data[this.key]);
         })
       }
 
@@ -61285,29 +62105,29 @@ class SmartSelectComponent extends SmartSelectField {
 
   setValue(value, flags = {}) {
     // console.log("value line 1875" + this.component.label, value)
-    if(value && String(value).length > 0){
+    if (value && String(value).length > 0) {
       $(".barcode-select-error").remove();
     }
-      if (localStorage.getItem('renderMode') === 'html' && this.component.dataSrc === 'values') {
-        this.component.data.values.filter((data) => {
-          if ((value && data.value === value) || (value && data.value === String(value))) {
-            value = data.label;
-          };
-        })
+    if (localStorage.getItem('renderMode') === 'html' && this.component.dataSrc === 'values') {
+      this.component.data.values.filter((data) => {
+        if ((value && data.value === value) || (value && data.value === String(value))) {
+          value = data.label;
+        };
+      })
+    }
+    if (localStorage.getItem('renderMode') === 'html' && this.component.dataSrc === 'masterdata' && !this.component.multiple) {
+      var tmplt = this.component.template;
+      var str1 = tmplt.substring(tmplt.lastIndexOf('.') + 1, tmplt.length);
+      var label = str1.substring(0, str1.indexOf('}'), str1.length);
+      label = label.trim();
+
+      this.component.masterdata.filter((data) => {
+        if ((value && data[this.component.valueProperty] === value) || (value && data[this.component.valueProperty] === String(value))) {
+          value = data[label];
+        }
+      })
     }
-      if (localStorage.getItem('renderMode') === 'html' && this.component.dataSrc === 'masterdata' && !this.component.multiple) {
-        var tmplt = this.component.template;
-        var str1 = tmplt.substring(tmplt.lastIndexOf('.') + 1, tmplt.length);
-        var label = str1.substring(0, str1.indexOf('}'), str1.length);
-        label = label.trim();
 
-        this.component.masterdata.filter((data) => {
-          if ((value && data[this.component.valueProperty] === value) || (value && data[this.component.valueProperty] === String(value))) {
-            value = data[label];
-          }
-        })
-      }
-    
     const previousValue = this.dataValue;
     // console.log("value line 1900 " + this.component.label, value)
     const changed = this.updateValue(value, flags);
@@ -61319,10 +62139,10 @@ class SmartSelectComponent extends SmartSelectField {
     if (this.component.multiple && Array.isArray(value)) {
       value = value.map(value => {
         if (typeof value === 'boolean' || typeof value === 'number') {
-    console.log("value line 1910 " + this.component.label, value)
+          console.log("value line 1910 " + this.component.label, value)
           return value.toString();
         }
-    console.log("value line 1914 " + this.component.label, value)
+        console.log("value line 1914 " + this.component.label, value)
         return value;
       });
     } else {
@@ -61354,10 +62174,10 @@ class SmartSelectComponent extends SmartSelectField {
     // Add the value options.
     this.itemsLoaded.then(() => {
       this.addValueOptions();
-    //  console.log("value line 1945 " + this.component.label, value)
+      //  console.log("value line 1945 " + this.component.label, value)
       this.setChoicesValue(value, hasPreviousValue, flags);
     });
-  
+
     return changed;
   }
 
@@ -61404,7 +62224,7 @@ class SmartSelectComponent extends SmartSelectField {
       if (hasValue) {
         const values = Array.isArray(value) ? value : [value];
         if (!_.isEqual(this.dataValue, this.defaultValue) && this.selectOptions.length < 2
-        || (this.selectData && flags.fromSubmission)) {
+          || (this.selectData && flags.fromSubmission)) {
           const { value, label } = this.selectValueAndLabel(this.dataValue);
           this.addOption(value, label);
         }
@@ -61477,14 +62297,14 @@ class SmartSelectComponent extends SmartSelectField {
    */
   getOptionValue(value) {
     return _.isObject(value) && this.isEntireObjectDisplay()
-    ? this.normalizeSingleValue(value)
-    : _.isObject(value) && (this.valueProperty || this.component.key !== 'resource')
-      ? value
-      : _.isObject(value) && !this.valueProperty
-        ? this.interpolate(this.component.template, { item: value }).replace(/<\\/?[^>]+(>|$)/g, '')
-        : _.isNull(value)
-          ? this.emptyValue
-          : String(this.normalizeSingleValue(value));
+      ? this.normalizeSingleValue(value)
+      : _.isObject(value) && (this.valueProperty || this.component.key !== 'resource')
+        ? value
+        : _.isObject(value) && !this.valueProperty
+          ? this.interpolate(this.component.template, { item: value }).replace(/<\\/?[^>]+(>|$)/g, '')
+          : _.isNull(value)
+            ? this.emptyValue
+            : String(this.normalizeSingleValue(value));
   }
 
   /**
@@ -61600,19 +62420,19 @@ class SmartSelectComponent extends SmartSelectField {
         items: convertToString(this.getNormalizedValues(), 'value'),
         valueProperty: 'value',
       } : {
-        items: convertToString(this.getCustomItems(), this.valueProperty),
-        valueProperty: this.valueProperty,
-      };
+          items: convertToString(this.getCustomItems(), this.valueProperty),
+          valueProperty: this.valueProperty,
+        };
       const getFromValues = () => {
         const initialValue = _.find(items, [valueProperty, value]);
         const values = this.defaultSchema.data.values || [];
         return _.isEqual(initialValue, values[0]) ? '-' : initialValue;
       };
       value = (this.component.multiple && Array.isArray(value))
-      ? _.filter(items, (item) => value.includes(item.value))
-      : valueProperty
-        ? getFromValues() ?? { value, label: value }
-        : value;
+        ? _.filter(items, (item) => value.includes(item.value))
+        : valueProperty
+          ? getFromValues() ?? { value, label: value }
+          : value;
     }
 
     if (_.isString(value)) {
@@ -61628,7 +62448,7 @@ class SmartSelectComponent extends SmartSelectField {
     if (Array.isArray(value)) {
       const items = [];
       value.forEach(item => items.push(getTemplateValue(item)));
-      if (this.component.dataSrc === 'resource' &&  items.length > 0 ) {
+      if (this.component.dataSrc === 'resource' && items.length > 0) {
         return items.join(', ');
       }
       else if (items.length > 0) {
@@ -64975,12 +65795,27 @@ function FormOnBackNavigation() {
 function initialButtonSetup(privateExternal, permission) {
   const saveBtn = document.getElementById("saveBtn");
   const submitBtn = document.getElementById("submitBtn");
+  const completeOption = document.getElementById("completeOption");
+  const saveOption = document.getElementById("saveOption");
+  const completeDivider = document.getElementById("completeDivider");
+  const saveDivider = document.getElementById("saveDivider");
+
   if (!saveBtn || !submitBtn) return;
 
   const isPrivate = privateExternal === true || privateExternal === "true";
   const isPublic = privateExternal === false || privateExternal === "false";
   const permissionMode = String(permission || "").toLowerCase();
 
+  // Helper to toggle dropdown items
+  const toggleDropdown = (option, divider, show) => {
+    if (option) option.style.display = show ? "block" : "none";
+    if (divider) divider.style.display = show ? "block" : "none";
+  };
+
+  // Default: Hide dropdown specific items
+  toggleDropdown(completeOption, completeDivider, false);
+  toggleDropdown(saveOption, saveDivider, false);
+
   // READ ONLY
   if (permissionMode === "read") {
     console.log("Mode: READ \u2192 Hide all buttons");
@@ -64988,31 +65823,72 @@ function initialButtonSetup(privateExternal, permission) {
     submitBtn.style.display = "none";
   }
 
-  // PUBLIC FORM
-  else if (
-    isPublic &&
-    (permissionMode === "writesingle" || permissionMode === "writemultiple")
-  ) {
-    console.log("Mode: PUBLIC WRITE \u2192 Show submit (disabled)");
+  // PUBLIC FORM - writemultiple
+  else if (isPublic && permissionMode === "writemultiple") {
+    console.log("Mode: PUBLIC WRITEMULTIPLE \u2192 Show Complete button only (disabled)");
     saveBtn.style.display = "none";
     submitBtn.style.display = "";
+    submitBtn.innerHTML = '<i class="icon clipboard check large"></i> Complete';
     submitBtn.disabled = true;
+
+    // No dropdown options for public writemultiple
+    toggleDropdown(completeOption, completeDivider, false);
+    toggleDropdown(saveOption, saveDivider, false);
   }
 
-  // PRIVATE FORM - writemultiple
-  else if (isPrivate && permissionMode === "writemultiple") {
-    console.log("Mode: PRIVATE WRITEMULTIPLE \u2192 Show submit (disabled)");
+  // PUBLIC FORM - writesingle
+  else if (isPublic && permissionMode === "writesingle") {
+    console.log("Mode: PUBLIC WRITESINGLE \u2192 Show submit (disabled)");
     saveBtn.style.display = "none";
     submitBtn.style.display = "";
+    submitBtn.innerHTML = '<i class="icon save"></i> Submit';
     submitBtn.disabled = true;
   }
 
+  // PRIVATE FORM - writemultiple
+  else if (isPrivate && permissionMode === "writemultiple") {
+    const showCompleteAlways =
+      window.__unviredFormsOptions?.showCompleteAlways === true ||
+      window.__unviredFormsOptions?.showCompleteAlways === "true";
+
+    if (showCompleteAlways) {
+      console.log(
+        "Mode: PRIVATE WRITEMULTIPLE (ShowCompleteAlways) \u2192 Show Save and Complete"
+      );
+      saveBtn.style.display = "";
+      submitBtn.style.display = "";
+      submitBtn.innerHTML = '<i class="icon clipboard check large"></i> Complete';
+
+      saveBtn.disabled = true; // Initially empty
+      submitBtn.disabled = true; // Initially not complete
+
+      toggleDropdown(completeOption, completeDivider, false);
+      toggleDropdown(saveOption, saveDivider, false);
+    } else {
+      console.log(
+        "Mode: PRIVATE WRITEMULTIPLE \u2192 Show save (disabled), Complete hidden initially"
+      );
+      saveBtn.style.display = "";
+      submitBtn.style.display = "none";
+      saveBtn.disabled = true;
+
+      // Initially hide Complete in Dropdown (will show when any field is filled)
+      toggleDropdown(completeOption, completeDivider, false);
+    }
+  }
+
   // PRIVATE FORM - writesingle
   else if (isPrivate && permissionMode === "writesingle") {
-    console.log("Mode: PRIVATE WRITESINGLE \u2192 Show save (disabled)");
-    saveBtn.style.display = "";
-    submitBtn.style.display = "none";
-    saveBtn.disabled = true;
+    console.log(
+      "Mode: PRIVATE WRITESINGLE \u2192 Show submit (disabled), Save in Dropdown"
+    );
+    saveBtn.style.display = "none";
+    submitBtn.style.display = "";
+    submitBtn.innerHTML = '<i class="icon clipboard check large"></i> Complete';
+    submitBtn.disabled = true;
+
+    // Show Save in Dropdown
+    toggleDropdown(saveOption, saveDivider, true);
   }
 
   // DEFAULT / UNKNOWN
@@ -65020,8 +65896,14 @@ function initialButtonSetup(privateExternal, permission) {
     console.log("Mode: DEFAULT / UNKNOWN \u2192 Show submit (disabled)");
     saveBtn.style.display = "none";
     submitBtn.style.display = "";
+    submitBtn.innerHTML = '<i class="icon clipboard large"></i> Submit';
     submitBtn.disabled = true;
   }
+
+  // Check if More button should be visible based on dropdown content
+  if (typeof window.checkMoreButtonVisibility === "function") {
+    window.checkMoreButtonVisibility();
+  }
 }
 
 function onChangeButtonSetup(
@@ -65043,10 +65925,16 @@ function onChangeButtonSetup(
       v !== undefined &&
       v !== null &&
       v !== "" &&
-      !(Array.isArray(v) && v.length === 0)
+      v !== false &&
+      !(Array.isArray(v) && v.length === 0) &&
+      !(typeof v === "object" && !Array.isArray(v) && Object.keys(v).length === 0)
   );
   const isComplete = completionPercentage >= 100;
 
+  const requireComplete =
+    window.__unviredFormsOptions?.requireCompleteForm === true ||
+    window.__unviredFormsOptions?.requireCompleteForm === "true";
+
   // READ ONLY
   if (permissionMode === "read") {
     console.log("Mode: READ \u2192 Hide all buttons");
@@ -65058,38 +65946,121 @@ function onChangeButtonSetup(
   // PRIVATE FORM - writesingle
   if (isPrivate && permissionMode === "writesingle") {
     console.log("Mode: PRIVATE WRITESINGLE");
+    // Main: Complete (Submit)
     saveBtn.style.display = "none";
     submitBtn.style.display = "";
-    submitBtn.disabled = !hasAnyValue;
+
+    // Logic: Disable Complete until 100% if required, otherwise just check if has values
+    submitBtn.disabled = requireComplete ? !isComplete : !hasAnyValue;
+
+    // Check if More button should be visible
+    if (typeof window.checkMoreButtonVisibility === "function") {
+      window.checkMoreButtonVisibility();
+    }
     return;
   }
 
   // PRIVATE FORM - writemultiple
   if (isPrivate && permissionMode === "writemultiple") {
     console.log("Mode: PRIVATE WRITEMULTIPLE");
-    if (isComplete) {
-      console.log("\u2192 Complete: Show submit");
-      saveBtn.style.display = "none";
-      submitBtn.style.display = "";
-      submitBtn.disabled = false;
-    } else {
-      console.log("\u2192 Incomplete: Show save");
+
+    const completeOption = document.getElementById("completeOption");
+    const saveOption = document.getElementById("saveOption");
+    const completeDivider = document.getElementById("completeDivider");
+    const saveDivider = document.getElementById("saveDivider");
+
+    // Helper to toggle dropdown items
+    const toggleDropdown = (option, divider, show) => {
+      if (option) option.style.display = show ? "block" : "none";
+      if (divider) divider.style.display = show ? "block" : "none";
+    };
+
+    const showCompleteAlways =
+      window.__unviredFormsOptions?.showCompleteAlways === true ||
+      window.__unviredFormsOptions?.showCompleteAlways === "true";
+
+    if (showCompleteAlways) {
       saveBtn.style.display = "";
-      submitBtn.style.display = "none";
+      submitBtn.style.display = "";
+      submitBtn.innerHTML = '<i class="icon clipboard check large"></i> Complete';
+
       saveBtn.disabled = !hasAnyValue;
+      submitBtn.disabled = requireComplete ? !isComplete : !hasAnyValue;
+
+      toggleDropdown(completeOption, completeDivider, false);
+      toggleDropdown(saveOption, saveDivider, false);
+    } else {
+      if (isComplete) {
+        // 100% Complete: Main button = Complete, Dropdown = Save
+        console.log(
+          "  \u2192 100% Complete: Showing Complete button, Save in dropdown"
+        );
+        saveBtn.style.display = "none";
+        submitBtn.style.display = "";
+        submitBtn.innerHTML = '<i class="icon clipboard check large"></i> Complete';
+        submitBtn.disabled = false;
+
+        // Show Save in dropdown, hide Complete
+        toggleDropdown(saveOption, saveDivider, true);
+        toggleDropdown(completeOption, completeDivider, false);
+      } else if (hasAnyValue) {
+        // 1-99% Complete: Main button = Save, Dropdown = Complete
+        console.log(
+          "  \u2192 Partially filled: Showing Save button, Complete in dropdown"
+        );
+        saveBtn.style.display = "";
+        submitBtn.style.display = "none";
+        saveBtn.disabled = false;
+
+        // Show Complete in dropdown, hide Save
+        toggleDropdown(completeOption, completeDivider, true);
+        toggleDropdown(saveOption, saveDivider, false);
+      } else {
+        // 0% Complete: Main button = Save (disabled), Complete hidden
+        console.log("  \u2192 Empty form: Save disabled, Complete hidden");
+        saveBtn.style.display = "";
+        submitBtn.style.display = "none";
+        saveBtn.disabled = true;
+
+        // Hide both in dropdown
+        toggleDropdown(completeOption, completeDivider, false);
+        toggleDropdown(saveOption, saveDivider, false);
+      }
+    }
+
+    // Check if More button should be visible based on dropdown content
+    if (typeof window.checkMoreButtonVisibility === "function") {
+      window.checkMoreButtonVisibility();
     }
     return;
   }
 
-  // PUBLIC FORM
-  if (
-    isPublic &&
-    (permissionMode === "writesingle" || permissionMode === "writemultiple")
-  ) {
-    console.log("Mode: PUBLIC WRITE \u2192 Show submit");
+  // PUBLIC FORM - writemultiple (Simple: Only Complete button)
+  if (isPublic && permissionMode === "writemultiple") {
+    console.log("Mode: PUBLIC WRITEMULTIPLE \u2192 Single Complete button");
     saveBtn.style.display = "none";
     submitBtn.style.display = "";
+    submitBtn.innerHTML = '<i class="icon clipboard check large"></i> Complete';
     submitBtn.disabled = !hasAnyValue;
+
+    // Check if More button should be visible
+    if (typeof window.checkMoreButtonVisibility === "function") {
+      window.checkMoreButtonVisibility();
+    }
+    return;
+  }
+
+  // PUBLIC FORM - writesingle
+  if (isPublic && permissionMode === "writesingle") {
+    console.log("Mode: PUBLIC WRITESINGLE \u2192 Show submit");
+    saveBtn.style.display = "none";
+    submitBtn.style.display = "";
+    submitBtn.disabled = !hasAnyValue;
+
+    // Check if More button should be visible
+    if (typeof window.checkMoreButtonVisibility === "function") {
+      window.checkMoreButtonVisibility();
+    }
     return;
   }
 
@@ -65098,6 +66069,11 @@ function onChangeButtonSetup(
   saveBtn.style.display = "none";
   submitBtn.style.display = "";
   submitBtn.disabled = !hasAnyValue;
+
+  // Check if More button should be visible based on dropdown content
+  if (typeof window.checkMoreButtonVisibility === "function") {
+    window.checkMoreButtonVisibility();
+  }
 }
 
 // Main form loader
@@ -65122,7 +66098,22 @@ async function loadRNform(
 
   // document.getElementById("formio-cmt").innerHTML = "";
 
-  Formio.use(window.semantic.default || window.semantic);
+  // Formio should already be loaded by index.js
+  if (typeof Formio === "undefined") {
+    console.error("\u274C Formio library not loaded");
+    sendEventCallback({
+      type: "ERROR",
+      errorMessage: "ErrorCode : 016, Formio library not loaded",
+      data: { reason: "Formio library not loaded" },
+    });
+    return;
+  }
+
+  if (window.semantic) {
+    Formio.use(window.semantic.default || window.semantic);
+  } else {
+    console.warn("Semantics UI not loaded, skipping Formio.use(semantic)");
+  }
 
   try {
     // Determine form configuration based on mode
@@ -65161,12 +66152,29 @@ async function loadRNform(
       formConfig.viewHtml = false;
     }
 
+    const formElement = document.getElementById("formio");
+    if (!formElement) {
+      throw new Error("DOM Element #formio not found");
+    }
+
+    // Sanitize template to prevent auto-submission to Form.io API
+    if (template) {
+      if (template.src) delete template.src;
+      if (template.url) delete template.url;
+      if (template.project) delete template.project;
+      if (template.projectId) delete template.projectId;
+      if (template.projectUrl) delete template.projectUrl;
+    }
+
+    // Create form (single attempt - Formio is already loaded by index.js)
     formObj = await Formio.createForm(
-      document.getElementById("formio"),
+      formElement,
       template,
       formConfig
     );
 
+
+
     // Store initial form data after first change event (ensures all defaults applied)
     let initialDataSet = false;
     formObj.on("change", () => {
@@ -65274,6 +66282,9 @@ async function loadRNform(
         };
       }
 
+      // Calculate initial progress immediately
+      executeProgressCalculation(privateExternal, permission);
+
       // Hide FormIO submit button component and wizard buttons in readOnly mode
       if (mode == "readOnly") {
         const submitComponents = document.querySelectorAll(
@@ -65325,12 +66336,19 @@ async function loadRNform(
       if (fileInput) fileInput.setAttribute("accept", "*/*");
     });
   } catch (error) {
-    console.error("\u274C Error creating form:", error);
+    console.error("\u274C Error creating form (after retries):", error);
+
+    // Ensure loader is hidden even on error
+    const sdkLoader = document.getElementById('sdk-form-loader');
+    if (sdkLoader) {
+      sdkLoader.classList.add('hidden');
+    }
+
     sendEventCallback({
       type: "ERROR",
       errorMessage:
-        "ErrorCode : 005, Form render error. Contact your admin or tech team.",
-      data: { technicalError: error },
+        "ErrorCode : 005, Formio not rendered the forms",
+      data: { reason: "Failed to render form after retries", technicalError: error },
     });
   }
 }
@@ -65340,209 +66358,292 @@ let changeTimeout = null;
 let lastDataHash = null;
 let mandatoryFieldsCache = null;
 
-function setupOnChange(privateExternal, permission) {
+// Build mandatory fields cache once
+function buildMandatoryFieldsCache() {
+  if (mandatoryFieldsCache) return mandatoryFieldsCache;
+  if (!formObj) return [];
+
+  const cache = [];
+  // Layout components do not have input data themselves but contain children
+  // We traverse them but keep the current path unless the component modifies it?
+  // Actually, standard FormIO layouts don't add to data path, but containers do.
+
+  function cacheMandatoryFields(components, path = "") {
+    if (!Array.isArray(components)) return;
+    components.forEach((comp) => {
+      // 'comp' should be the Component Instance here
+      if (!comp) return;
+
+      // The schema is usually in comp.component, but fallback to comp if it's already a schema (shouldn't be if traversing instances)
+      const schema = comp.component || comp;
+
+      let fieldPath = path;
+
+      // List of components that are "Passthrough" for data path (Layouts)
+      const isLayout = [
+        "columns", "panel", "fieldset", "well", "table", "tabs", "content", "htmlelement"
+      ].includes(schema.type);
+
+      // Determine path
+      if (!isLayout) {
+        fieldPath = path ? \`\${path}.\${schema.key}\` : schema.key;
+      }
+
+      const inputTypes = [
+        "textfield", "textarea", "number", "checkbox", "radio", "select", "selectboxes",
+        "email", "url", "day", "datetime", "file", "datamap", "tree", "survey",
+        "signature", "datagrid", "editgrid", "container"
+      ];
+
+      // CACHE IF REQUIRED
+      if (
+        inputTypes.includes(schema.type) &&
+        schema.validate?.required
+      ) {
+        cache.push({
+          key: schema.key,
+          type: schema.type,
+          path: fieldPath,
+          comp: schema,     // The static schema
+          instance: comp,   // The runtime component instance (has .visible, .checkCondition)
+        });
+      }
+
+      // RECURSION
+      // We must recurse on the INSTANCE'S components to keep getting instances.
+      // 'comp.components' is the array of child instances on a Container/Panel/etc.
+      // 'comp.columns' is for Columns component, but each col has .components
+
+      // Standard container-like components (Panel, Container, etc.)
+      if (Array.isArray(comp.components)) {
+        cacheMandatoryFields(comp.components, fieldPath);
+      }
+
+      // Columns component handles children differently in instances?
+      // Usually comp.columns is an array of objects which contain .components (instances)
+      if (Array.isArray(comp.columns)) {
+        comp.columns.forEach((col) => {
+          if (Array.isArray(col.components)) {
+            cacheMandatoryFields(col.components, fieldPath);
+          }
+        });
+      }
+
+      // DataGrid/EditGrid rows are generated dynamically. 
+      // The \`comp\` instance might have \`rows\` property? 
+      // Actually for DataGrid, we iterate the data rows in 'execute', not the components here.
+      // BUT if the DataGrid has static \`components\` (the column definitions), we might need to check them?
+      // The schema has .components (the columns). 
+      // The instance has .components (the flattened list of all cell components across all rows? Or just the column patterns?)
+      // For progress calc, we handled DataGrid specifically in \`isFilled\` or by flattening.
+      // If we want to support required fields INSIDE a datagrid row, we need to handle that.
+      // Current logic: We treat DataGrid as a single "filled" item if it has rows. 
+      // We do NOT currently check if fields INSIDE the row are filled if the datagrid itself is "filled".
+      // Users issue implies specific internal fields. 
+
+      // NOTE: User's reported "Total mandatory: 23" suggests individual fields are counted.
+      // If \`comp.components\` exists on a DataGrid instance, it usually holds the column definitions as components.
+      // Let's stick to standard recursion for now.
+    });
+  }
+
+  cacheMandatoryFields(formObj.components);
+  mandatoryFieldsCache = cache;
+  return cache;
+}
+
+function executeProgressCalculation(privateExternal, permission) {
   if (!formObj) return;
 
-  // Build mandatory fields cache once
-  function buildMandatoryFieldsCache() {
-    if (mandatoryFieldsCache) return mandatoryFieldsCache;
-
-    const cache = [];
-
-    function cacheMandatoryFields(components, path = "") {
-      components.forEach((comp) => {
-        if (!comp) return;
-        const actualComp = comp.component || comp;
-        const fieldPath = path ? \`\${path}.\${actualComp.key}\` : actualComp.key;
-
-        const inputTypes = [
-          "textfield",
-          "textarea",
-          "number",
-          "checkbox",
-          "radio",
-          "select",
-          "selectboxes",
-          "email",
-          "url",
-          "day",
-          "datetime",
-          "file",
-          "datamap",
-          "tree",
-          "survey",
-          "signature",
-        ];
+  const data = formObj.data || {};
+  const dataHash = JSON.stringify(data);
 
-        if (
-          inputTypes.includes(actualComp.type) &&
-          actualComp.validate?.required
-        ) {
-          cache.push({
-            key: actualComp.key,
-            type: actualComp.type,
-            path: fieldPath,
-            comp: actualComp,
-          });
-        }
+  if (dataHash === lastDataHash) return;
+  lastDataHash = dataHash;
 
-        // Recurse into children
-        if (Array.isArray(actualComp.components)) {
-          cacheMandatoryFields(actualComp.components, fieldPath);
-        }
-        if (Array.isArray(actualComp.columns)) {
-          actualComp.columns.forEach((col) => {
-            if (Array.isArray(col.components)) {
-              cacheMandatoryFields(col.components, fieldPath);
-            }
-          });
+  const mandatoryFields = buildMandatoryFieldsCache();
+  let mandatory = mandatoryFields.length;
+  let filledMandatory = 0;
+
+  function isFilled(comp, value) {
+    if (Array.isArray(value)) {
+      // Logic for array values (files, datagrid rows, etc.)
+      const arrayNativeTypes = ['file', 'datagrid', 'editgrid', 'datamap', 'selectboxes'];
+      const isNativeArray = arrayNativeTypes.includes(comp.type) || comp.multiple;
+
+      if (!isNativeArray) {
+        // Assume row-values from extracted path -> all must range
+        return value.length > 0 && value.every(v => isFilled(comp, v));
+      }
+
+      if (comp.type === 'file' && value.length > 0 && Array.isArray(value[0])) {
+        // File inside datagrid?
+        return value.every(v => isFilled(comp, v));
+      }
+    }
+
+    switch (comp.type) {
+      case "selectboxes":
+        return Object.values(value || {}).some(Boolean);
+      case "datamap":
+      case "tree":
+        return value && Object.keys(value).length > 0;
+      case "survey":
+        // Check if all questions in the survey are answered
+        if (comp.questions && Array.isArray(comp.questions)) {
+          return value && Object.keys(value).length >= comp.questions.length;
         }
-        if (Array.isArray(actualComp.rows)) {
-          actualComp.rows.forEach((row) => {
-            if (Array.isArray(row)) {
-              row.forEach((cell) => {
-                if (Array.isArray(cell.components)) {
-                  cacheMandatoryFields(cell.components, fieldPath);
-                }
-              });
-            }
-          });
+        return value && Object.keys(value).length > 0;
+      case "file":
+        return Array.isArray(value) && value.length > 0;
+      case "checkbox":
+        return value === true;
+      case "editgrid":
+      case "datagrid":
+        return Array.isArray(value) && value.length > 0;
+      case "signature":
+        return !!value;
+      default:
+        return value !== undefined && value !== null && value !== "";
+    }
+  }
+
+  const activeMandatoryFields = [];
+
+  mandatoryFields.forEach((entry) => {
+    // Check conditional visibility using Formio's checkCondition if available, or fallback to visible property
+    // If a component is conditionally hidden, it should not count as mandatory
+    let isVisible = true;
+    if (entry.instance) {
+      // Preferred: usage of Formio's internal checkCondition if accessible
+      // But often checking .visible on the instance is sufficient as Formio updates it
+      if (entry.instance.visible === false) isVisible = false;
+
+      // Double check with checkCondition if available to be sure about complex conditions
+      if (isVisible && typeof entry.instance.checkCondition === 'function') {
+        if (!entry.instance.checkCondition(null, data)) {
+          isVisible = false;
         }
-      });
+      }
     }
 
-    cacheMandatoryFields(formObj.components);
-    mandatoryFieldsCache = cache;
-    return cache;
+    if (!isVisible) return;
+
+    // Check if parent is visible (basic check, could be recursive but starting here)
+    if (entry.instance && entry.instance.parent && entry.instance.parent.visible === false) return;
+
+    activeMandatoryFields.push(entry);
+  });
+
+  mandatory = activeMandatoryFields.length;
+  filledMandatory = 0;
+
+  activeMandatoryFields.forEach(({ key, type, path, comp }) => {
+    let value = getValueFromData(data, path);
+    const filled = isFilled(comp, value);
+    if (filled) filledMandatory++;
+  });
+
+  console.log("\u2705 Total mandatory fields:", mandatory);
+  console.log("\u2705 Filled mandatory fields:", filledMandatory);
+  const completion =
+    mandatory === 0 ? 100 : Math.round((filledMandatory / mandatory) * 100);
+  calculationPercentage = completion; // Update global
+  completeFlag = completion >= 100;   // Update global
+
+  console.log("\u{1F4CA} Completion %:", completion);
+
+  onChangeButtonSetup(
+    completion,
+    formObj.data,
+    privateExternal,
+    permission
+  );
+
+  // Update progress bar
+  const progressBar = document.getElementById("progress-bar");
+  if (progressBar) {
+    const bar = progressBar.querySelector(".progress");
+    const badge = progressBar.querySelector(".badge");
+
+    bar.style.width = \`\${completion}%\`;
+    badge.textContent = \`\${completion}%\`;
+
+    let left = completion;
+    if (completion <= 0) {
+      left = 0.5;
+      bar.style.width = \`\${0.5}%\`;
+      if (window.innerWidth > 768) badge.style.transform = "translateX(2%)";
+      else if (window.innerWidth > 480) badge.style.transform = "translateX(2%)";
+      else badge.style.transform = "translateX(1%)";
+    } else if (completion >= 100) {
+      left = 99.5;
+      if (window.innerWidth > 768) badge.style.transform = "translateX(-65%)";
+      else if (window.innerWidth > 480) badge.style.transform = "translateX(-85%)";
+      else badge.style.transform = "translateX(-105%)";
+    } else {
+      // Reset transform if not edge case
+      badge.style.transform = "translateX(-50%)"; // Standard centering, though original didn't have this explicitly in else
+    }
+    badge.style.left = \`\${left - 0.25}%\`;
   }
+}
 
-  formObj.on("change", (submission) => {
-    // Clear existing timeout
-    if (changeTimeout) {
-      clearTimeout(changeTimeout);
+
+// Helper to safely get value from data using path strings, handling arrays (datagrids)
+function getValueFromData(data, path) {
+  if (data === undefined || data === null || !path) return undefined;
+
+  // If path has no dots, it's a direct key
+  if (path.indexOf('.') === -1) {
+    // Special handling: if data is array, map it (unless path is purely index, but here assuming keys)
+    if (Array.isArray(data)) {
+      return data.map(item => item[path]);
     }
+    return data[path];
+  }
 
-    // Debounce the change handler
-    changeTimeout = setTimeout(() => {
-      const data = submission?.data || formObj.data || {};
-      const dataHash = JSON.stringify(data);
-
-      // Skip if data hasn't actually changed
-      if (dataHash === lastDataHash) return;
-      lastDataHash = dataHash;
-
-      const mandatoryFields = buildMandatoryFieldsCache();
-      let mandatory = mandatoryFields.length;
-      let filledMandatory = 0;
-
-      function isFilled(comp, value) {
-        switch (comp.type) {
-          case "selectboxes":
-            return Object.values(value || {}).some(Boolean);
-          case "datamap":
-          case "tree":
-          case "survey":
-            return value && Object.keys(value).length > 0;
-          case "file":
-            return Array.isArray(value) && value.length > 0;
-          case "checkbox":
-            return value === true;
-          case "editgrid":
-          case "datagrid":
-            return Array.isArray(value) && value.length > 0;
-          case "signature":
-            return !!value;
-          default:
-            return value !== undefined && value !== null && value !== "";
-        }
-      }
+  const keys = path.split(".");
+  let current = data;
 
-      // Only log and count filled fields
-      mandatoryFields.forEach(({ key, type, comp }) => {
-        let value;
-        try {
-          const formComp = formObj.getComponent(key);
-          value =
-            formComp && typeof formComp.getValue === "function"
-              ? formComp.getValue()
-              : data[key];
-        } catch (e) {
-          value = data[key];
-        }
+  for (let i = 0; i < keys.length; i++) {
+    const key = keys[i];
+    if (current === undefined || current === null) return undefined;
 
-        const filled = isFilled(comp, value);
-        if (filled) filledMandatory++;
+    if (Array.isArray(current)) {
+      // We hit an array (e.g. datagrid rows), but we have more keys to traverse.
+      // We must map the rest of the path over each item in the array.
+      const remainingPath = keys.slice(i).join(".");
+      return current.map(item => getValueFromData(item, remainingPath));
+    }
 
-        console.log(
-          \`\u{1F50E} Field: \${key} | type: \${type} | required: true | value:\`,
-          value,
-          "| filled:",
-          filled
-        );
-      });
+    current = current[key];
+  }
+  return current;
+}
 
-      console.log("\u2705 Total mandatory fields:", mandatory);
-      console.log("\u2705 Filled mandatory fields:", filledMandatory);
-      const completion =
-        mandatory === 0 ? 100 : Math.round((filledMandatory / mandatory) * 100);
-      console.log("\u{1F4CA} Completion %:", completion);
-
-      onChangeButtonSetup(
-        completion,
-        formObj.data,
-        privateExternal,
-        permission
-      );
+function setupOnChange(privateExternal, permission) {
+  if (!formObj) return;
 
-      // Update progress bar if exists
-      const progressBar = document.getElementById("progress-bar");
-      if (progressBar) {
-        const bar = progressBar.querySelector(".progress");
-        const badge = progressBar.querySelector(".badge");
-
-        // Set bar width
-        bar.style.width = \`\${completion}%\`;
-
-        // Update badge text
-        badge.textContent = \`\${completion}%\`;
-
-        // Calculate badge left relative to container
-        let left = completion;
-
-        // Edge cases: keep badge inside screen
-        if (completion <= 0) {
-          left = 0.5; // slightly inside
-          bar.style.width = \`\${0.5}%\`;
-          if (window.innerWidth > 768) {
-            badge.style.transform = "translateX(2%)"; // desktop
-          } else if (window.innerWidth > 480) {
-            badge.style.transform = "translateX(2%)"; // tablet
-          } else if (window.innerWidth > 360) {
-            badge.style.transform = "translateX(2%)"; // mobile
-          } else {
-            badge.style.transform = "translateX(1%)"; // very small phone
-          }
-        }
-        if (completion >= 100) {
-          left = 99.5; // slightly inside
-          // Responsive translateX for different screen widths
-          if (window.innerWidth > 768) {
-            badge.style.transform = "translateX(-65%)"; // desktop
-          } else if (window.innerWidth > 480) {
-            badge.style.transform = "translateX(-85%)"; // tablet
-          } else if (window.innerWidth > 360) {
-            badge.style.transform = "translateX(-95%)"; // mobile
-          } else {
-            badge.style.transform = "translateX(-105%)"; // very small phone
-          }
-        }
+  formObj.on("change", (event) => {
+    // Blur datetime components on change to close the native keyboard/picker
+    if (event.changed?.component?.type === "datetime") {
+      document.activeElement.blur();
+    }
 
-        badge.style.left = \`\${left - 0.25}%\`;
-      }
+    // Clear existing timeout
+    if (changeTimeout) {
+      clearTimeout(changeTimeout);
+    }
+
+    // Invalidate cache to ensure conditional visibility updates are captured
+    mandatoryFieldsCache = null;
+
+    // Debounce the change handler
+    changeTimeout = setTimeout(() => {
+      executeProgressCalculation(privateExternal, permission);
     }, 300); // 300ms debounce delay
   });
-
-  // removed ad-hoc setTimeout: rely on formObj.formReady and LessRenderingComplete events
 }
 
 // Function to convert file objects back to IDs
@@ -65603,6 +66704,27 @@ function FormOnSubmit() {
     attachmentfileKeysSDK
   );
 
+  // Check strict completion requirement
+  const requireComplete =
+    window.__unviredFormsOptions?.requireCompleteForm === true ||
+    window.__unviredFormsOptions?.requireCompleteForm === "true";
+
+  if (!requireComplete) {
+    // Bypass validation and submit immediately
+    sendEventCallback({
+      type: FORM_EVENTS.SUBMIT,
+      message: "Success: Form submitted successfully (Validation Bypassed).",
+      data: {
+        formData: processedData,
+        completeFlag,
+        completionPercentage: calculationPercentage,
+        commentsData: FORM_COMMENTS_DATA,
+        result: processedData,
+      },
+    });
+    return;
+  }
+
   formObj
     .submit()
     .then((result) => {
@@ -65620,7 +66742,19 @@ function FormOnSubmit() {
     })
     .catch((error) => {
       console.error(error);
-      showDynamicModal("Error", [{ label: "OK" }], "Fill The Required Fields");
+      const errorMsg = (error && error.message) ? error.message : "Please check the form for errors.";
+      showDynamicModal("Error", [{ label: "OK" }], errorMsg);
+      sendEventCallback({
+        type: FORM_EVENTS.SUBMIT_ERROR,
+        errorMessage: "ErrorCode : 006, Formio not submit the form",
+        data: {
+          reason: "Form submission failed",
+          formData: processedData,
+          completeFlag,
+          completionPercentage: calculationPercentage,
+          technicalError: error,
+        },
+      });
     });
 }
 
@@ -65652,9 +66786,7 @@ async function loadComments() {
         window.FORM_VOB_ARR,
         window.FORM_USERS_LIST || []
       );
-      setTimeout(() => {
-        showCommentsView();
-      }, 500);
+      showCommentsView();
     } else {
       console.error("loadCommentsform is not a function");
     }
@@ -65666,6 +66798,22 @@ async function loadComments() {
 function FormOnSave() {
   if (!formObj) return;
 
+  const formData = formObj.getValue().data;
+  const hasAnyValue = Object.values(formData || {}).some(
+    (v) =>
+      v !== undefined &&
+      v !== null &&
+      v !== "" &&
+      v !== false &&
+      !(Array.isArray(v) && v.length === 0) &&
+      !(typeof v === "object" && !Array.isArray(v) && Object.keys(v).length === 0)
+  );
+
+  if (!hasAnyValue) {
+    showDynamicModal("Attention", [{ label: "OK" }], "Please fill at least one field before saving.");
+    return;
+  }
+
   showDynamicModal("Do you want to save the data?", [
     {
       label: "Yes",
@@ -65682,7 +66830,6 @@ function FormOnSave() {
             completionPercentage: calculationPercentage,
           },
         });
-        FormOnBackNavigation();
       },
     },
     {
@@ -65726,6 +66873,58 @@ function setImageData(imageData, id, fileName) {
 }
 
 // ============================================  MODAL   ===========================================================
+// Function to check if More dropdown has any visible items
+window.checkMoreButtonVisibility = function () {
+  const moreBtn = document.getElementById("unvired-more-btn");
+
+  // Safety check: if button doesn't exist, we can't do anything
+  if (!moreBtn) return;
+
+  const options = window.__unviredFormsOptions || {};
+
+  // If showMoreButton is explicitly false (from options), force hide
+  if (options.showMoreButton === false) {
+    moreBtn.style.display = "none";
+    return;
+  }
+
+  // Get all menu items in the dropdown
+  const completeOption = document.getElementById("completeOption");
+  const saveOption = document.getElementById("saveOption");
+  const documentsOption = document.getElementById("documentsOption");
+  const commentsItem = document.getElementById("comments-item");
+  const helpItem = document.getElementById("help-item");
+
+  // Check visibility logic:
+  // 1. Is the item actually displayed (style.display !== 'none')?
+  // 2. Is the item allowed by options (e.g. showComments, showHelp)?
+  //    For completeOption/saveOption, their display is managed by logic.
+  //    For documentsOption, its display is managed by logic.
+  //    For comments/help, they are often just static items toggled.
+
+  const isVisible = (el) => el && el.style.display !== "none";
+
+  // Assuming options.showComments/Help also imply the item SHOULD be visible if logic permits
+  // But logic might hide them. The 'isVisible' check handles dynamic logic.
+  // But for comments/help, they might be hidden initially.
+
+  const hasVisibleItems =
+    isVisible(completeOption) ||
+    isVisible(saveOption) ||
+    isVisible(documentsOption) ||
+    isVisible(commentsItem) ||
+    isVisible(helpItem); // Simplified: check actual DOM state
+
+  // If ANY item is visible, show the button. Otherwise hide.
+  if (hasVisibleItems) {
+    moreBtn.style.display = "";
+  } else {
+    moreBtn.style.display = "none";
+  }
+};
+
+window.checkMoreButtonVisibility();
+
 window.loadComments = loadComments;
 window.loadRNform = loadRNform;
 window.FormOnSave = FormOnSave;
@@ -65734,6 +66933,9 @@ window.setImageData = setImageData;
 window.FormOnSubmit = FormOnSubmit;
 window.resetFormCache = resetFormCache;
 
+// Notify that loadRNform is ready (for event-based coordination)
+document.dispatchEvent(new CustomEvent('LoadRNformReady'));
+
 })();
 
 // === SCRIPT_SEPARATOR ===
@@ -65789,7 +66991,7 @@ async function loadCommentsform(
   window.formObj.nosubmit = true;
 
   // Listen to form changes (optional, currently empty)
-  window.formObj.on("change", () => {});
+  window.formObj.on("change", () => { });
 
   // Initialize Recogito and store globally
   window.commentsResponse = Recogito.init({
@@ -65813,8 +67015,8 @@ async function loadCommentsform(
   });
 
   // Event listeners
-  window.commentsResponse.on("createAnnotation", function (annotation) {});
-  window.commentsResponse.on("updateAnnotation", function (annotation) {});
+  window.commentsResponse.on("createAnnotation", function (annotation) { });
+  window.commentsResponse.on("updateAnnotation", function (annotation) { });
   window.commentsResponse.on("selectAnnotation", function (annotation) {
     const eventCustom = new CustomEvent("annotateCss", { detail: true });
     document.dispatchEvent(eventCustom);
@@ -65865,6 +67067,13 @@ async function goToformRender() {
       }
     } catch (e) {
       console.error("Error reloading form:", e);
+      if (typeof sendEventCallback === 'function') {
+        sendEventCallback({
+          type: "ERROR",
+          errorMessage: "ErrorCode : 005, Formio not rendered the forms",
+          data: { reason: "Failed to reload forms", technicalError: e }
+        });
+      }
     }
   } else {
     console.error("loadRNform is not defined");
@@ -65937,71 +67146,118 @@ window.CommentOnBack = CommentOnBack;
 
     // Click outside handler for tooltip
     document.addEventListener('click', function (event) {
-      const moreBtn = document.getElementById('moreBtn');
+      const moreBtn = document.getElementById('unvired-more-btn');
       const tooltip = document.getElementById('moreTooltip');
       if (moreBtn && tooltip && !moreBtn.contains(event.target) && !tooltip.contains(event.target)) {
         tooltip.style.display = 'none';
       }
     });
-    `.split("\n\n// === SCRIPT_SEPARATOR ===\n\n");
-  if (scriptContents[0] && scriptContents[0].trim()) {
-    const jqueryScript = document.createElement("script");
-    jqueryScript.textContent = scriptContents[0];
-    document.head.appendChild(jqueryScript);
-  }
-  const formioScript = document.createElement("script");
-  formioScript.src = options.formioLibPath.formioPath;
-  document.head.appendChild(formioScript);
-  await new Promise((resolve) => {
-    const checkFormio = () => {
-      if (typeof window.Formio !== "undefined") {
-        resolve();
-      } else {
-        setTimeout(checkFormio, 100);
+    `.split(
+    "\n\n// === SCRIPT_SEPARATOR ===\n\n"
+  );
+  if (!window.__unviredSdkScriptsLoaded && !window.__unviredSdkScriptsLoading) {
+    window.__unviredSdkScriptsLoading = true;
+    console.log("Initializing Unvired SDK scripts...");
+    if (scriptContents[0] && scriptContents[0].trim()) {
+      const jqueryScript = document.createElement("script");
+      jqueryScript.textContent = scriptContents[0];
+      jqueryScript.setAttribute("data-unvired-script", "jquery");
+      document.head.appendChild(jqueryScript);
+    }
+    if (loaderElement) {
+      const loaderText = loaderElement.querySelector(".sdk-loader-text");
+      if (loaderText) loaderText.textContent = "Loading Formio Library...";
+    }
+    try {
+      await new Promise((resolve, reject) => {
+        const formioScript = document.createElement("script");
+        formioScript.src = options.formioLibPath.formioPath;
+        formioScript.async = false;
+        formioScript.onload = () => {
+          if (typeof window.Formio !== "undefined") {
+            resolve();
+          } else {
+            reject(new Error("Formio script loaded but window.Formio is undefined"));
+          }
+        };
+        formioScript.onerror = () => {
+          reject(new Error(`Failed to load Formio script from ${options.formioLibPath.formioPath}`));
+        };
+        document.head.appendChild(formioScript);
+      });
+    } catch (error) {
+      window.__unviredSdkScriptsLoading = false;
+      throw error;
+    }
+    for (let i = 1; i <= 2; i++) {
+      if (scriptContents[i] && scriptContents[i].trim()) {
+        const scriptElement = document.createElement("script");
+        scriptElement.textContent = scriptContents[i];
+        scriptElement.setAttribute("data-unvired-script", `recogito-${i}`);
+        document.head.appendChild(scriptElement);
       }
-    };
-    if (formioScript.onload !== void 0) {
-      formioScript.onload = checkFormio;
-    } else {
-      checkFormio();
     }
-  });
-  for (let i = 1; i <= 2; i++) {
-    if (scriptContents[i] && scriptContents[i].trim()) {
-      const scriptElement = document.createElement("script");
-      scriptElement.textContent = scriptContents[i];
-      document.head.appendChild(scriptElement);
-    }
-  }
-  if (scriptContents[3] && scriptContents[3].trim()) {
-    const lessScript = document.createElement("script");
-    lessScript.textContent = scriptContents[3];
-    document.head.appendChild(lessScript);
-  }
-  window.form = window.form || {};
-  window.platform = window.platform || {};
-  window.ResizeObserver = window.ResizeObserver || ResizeObserver;
-  if (typeof browserMD5File !== "undefined") {
-    window.form.BMF = new browserMD5File();
-  }
-  window.less = window.less || {};
-  if (typeof window.__Html5QrcodeLibrary__ !== "undefined") {
-    window.html5QrCode = window.__Html5QrcodeLibrary__;
-  }
-  for (let i = 4; i < scriptContents.length; i++) {
-    const scriptContent = scriptContents[i];
-    if (scriptContent.trim()) {
-      const scriptElement = document.createElement("script");
-      const isModuleScript = i >= scriptContents.length - 4;
-      if (isModuleScript) {
-        scriptElement.type = "module";
+    if (scriptContents[3] && scriptContents[3].trim()) {
+      const lessScript = document.createElement("script");
+      lessScript.textContent = scriptContents[3];
+      lessScript.setAttribute("data-unvired-script", "less");
+      document.head.appendChild(lessScript);
+    }
+    window.form = window.form || {};
+    window.platform = window.platform || {};
+    window.ResizeObserver = window.ResizeObserver || ResizeObserver;
+    if (typeof browserMD5File !== "undefined") {
+      window.form.BMF = new browserMD5File();
+    }
+    window.less = window.less || {};
+    if (typeof window.__Html5QrcodeLibrary__ !== "undefined") {
+      window.html5QrCode = window.__Html5QrcodeLibrary__;
+    }
+    for (let i = 4; i < scriptContents.length; i++) {
+      const scriptContent = scriptContents[i];
+      if (scriptContent.trim()) {
+        const scriptElement = document.createElement("script");
+        const isModuleScript = i >= scriptContents.length - 4;
+        if (isModuleScript) {
+          scriptElement.type = "module";
+        }
+        scriptElement.textContent = scriptContent;
+        scriptElement.setAttribute("data-unvired-script", `script-${i}`);
+        document.head.appendChild(scriptElement);
+      }
+    }
+    window.__unviredSdkScriptsLoaded = true;
+    window.__unviredSdkScriptsLoading = false;
+    console.log("\u2705 All Unvired SDK scripts loaded successfully");
+  } else if (window.__unviredSdkScriptsLoading) {
+    console.log("Scripts are being loaded by another instance, checking if already loaded...");
+    if (!window.__unviredSdkScriptsLoaded) {
+      console.warn("\u26A0\uFE0F Scripts marked as loading but not yet loaded - waiting...");
+      window.__unviredSdkScriptsLoaded = true;
+      window.__unviredSdkScriptsLoading = false;
+    }
+    console.log("\u2705 Scripts are available, continuing...");
+  } else {
+    console.log("Unvired SDK scripts already loaded, skipping injection.");
+    if (typeof window.Formio === "undefined") {
+      const errorMsg = `ErrorCode : 005, Formio library not available even though scripts were loaded. Path: ${options.formioLibPath.formioPath}`;
+      console.error(errorMsg);
+      if (loaderElement) {
+        loaderElement.classList.add("hidden");
       }
-      scriptElement.textContent = scriptContent;
-      document.head.appendChild(scriptElement);
-      await new Promise((resolve) => setTimeout(resolve, 50));
+      sendEventCallback2({
+        type: "ERROR",
+        errorMessage: errorMsg,
+        data: {
+          technicalError: new Error(errorMsg),
+          formioPath: options.formioLibPath.formioPath,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        }
+      });
+      throw new Error(errorMsg);
     }
+    console.log("\u2705 Formio verified (previously loaded)");
   }
-  await new Promise((resolve) => setTimeout(resolve, 500));
   window.FORM_TEMPLATE = mergedWithMasterData;
   window.FORM_PREVIOUS_DATA = submissionData;
   window.FORM_MODE = options.mode;
@@ -66013,6 +67269,7 @@ window.CommentOnBack = CommentOnBack;
   window.FORM_ENV = options.environmentVariable;
   window.FORM_THEME_DATA = options.themeData;
   window.FORM_USER_DATA = options.userData;
+  window.FORM_USERS_LIST = options.usersList;
   window.FORM_CONTROL_DATA = options.controlData;
   window.FORM_PRIVATE_EXTERNAL = options.privateExternal;
   window.FORM_PERMISSION = options.permission;
@@ -66027,13 +67284,18 @@ window.CommentOnBack = CommentOnBack;
     ONCHANGE: "FORM_ONCHANGE"
   };
   const backBtn = container.querySelector("#form-back-btn");
-  const moreBtn = container.querySelector("#moreBtn");
+  const moreBtn = container.querySelector("#unvired-more-btn");
   if (backBtn) {
     backBtn.style.display = options.showBackButton ? "inline-block" : "none";
   }
   if (moreBtn && !options.showMoreButton) {
     moreBtn.style.display = "none";
   }
+  window.__unviredFormsOptions = options;
+  window.checkDocumentsVisibility();
+  if (typeof window.checkMoreButtonVisibility === "function") {
+    window.checkMoreButtonVisibility();
+  }
   if (options.platform === "web") {
     window.platform = { isBrowser: true, isAndroid: false, iosPlatform: false };
   } else if (options.platform === "android") {
@@ -66071,6 +67333,8 @@ window.CommentOnBack = CommentOnBack;
   if (options.language) window.FORMIO_LANGUAGE = options.language;
   if (options.translations) window.FORMIO_I18N = options.translations;
   if (options.userData) {
+    window.firstName = options.userData.firstName;
+    window.lastName = options.userData.lastName;
     window.form = window.form || {};
     Object.assign(window.form, options.userData);
   }
@@ -66088,59 +67352,38 @@ window.CommentOnBack = CommentOnBack;
       sendEventCallback2
     );
   }
-  let attempts = 0;
-  const maxAttempts = 100;
-  const waitForLoadRNform = () => {
-    if (typeof window.loadRNform === "function") {
-      window.loadRNform(
-        mergedWithMasterData,
-        processedSubmissionData,
-        options.themeData,
-        options.mode,
-        options.language,
-        options.translations,
-        options.controlData,
-        options.privateExternal,
-        options.permission,
-        fileKeys
-      );
-      if (loaderElement && window.formObj) {
-        window.formObj.formReady.then(() => {
-          if (loaderElement) {
-            loaderElement.classList.add("hidden");
-            setTimeout(() => {
-              if (loaderElement && loaderElement.parentNode) {
-                loaderElement.parentNode.removeChild(loaderElement);
-              }
-            }, 400);
-          }
-        }).catch(() => {
-          setTimeout(() => {
-            if (loaderElement) {
-              loaderElement.classList.add("hidden");
-              setTimeout(() => {
-                if (loaderElement && loaderElement.parentNode) {
-                  loaderElement.parentNode.removeChild(loaderElement);
-                }
-              }, 400);
-            }
-          }, 2e3);
-        });
-      }
-    } else if (attempts < maxAttempts) {
-      attempts++;
-      console.log(`Waiting for loadRNform... attempt ${attempts}`);
-      setTimeout(waitForLoadRNform, 500);
-    } else {
-      console.error("window.loadRNform is not defined after waiting", {
-        availableFunctions: Object.keys(window).filter((key) => typeof window[key] === "function")
-      });
-      if (loaderElement) {
-        loaderElement.classList.add("hidden");
+  if (loaderElement) {
+    const loaderText = loaderElement.querySelector(".sdk-loader-text");
+    if (loaderText) loaderText.textContent = "Initializing Form...";
+  }
+  if (typeof window.loadRNform !== "function") {
+    console.log("\u23F3 loadRNform not ready yet, waiting for LoadRNformReady event...");
+    await new Promise((resolve) => {
+      const onReady = () => {
+        document.removeEventListener("LoadRNformReady", onReady);
+        console.log("\u2705 loadRNform is now ready");
+        resolve();
+      };
+      document.addEventListener("LoadRNformReady", onReady);
+      if (typeof window.loadRNform === "function") {
+        onReady();
       }
-    }
-  };
-  waitForLoadRNform();
+    });
+  } else {
+    console.log("\u2705 loadRNform is already available");
+  }
+  await window.loadRNform(
+    mergedWithMasterData,
+    processedSubmissionData,
+    options.themeData,
+    options.mode,
+    options.language,
+    options.translations,
+    options.controlData,
+    options.privateExternal,
+    options.permission,
+    fileKeys
+  );
   return {
     sendAction: (action) => {
       var _a2;
@@ -66158,6 +67401,51 @@ window.CommentOnBack = CommentOnBack;
     }
   };
 }
+window.closeDocumentsModal = function() {
+  if (typeof $ !== "undefined" && $.fn.modal) {
+    $("#documentsModal").modal("hide");
+  } else {
+    const modal = document.getElementById("documentsModal");
+    if (modal) {
+      modal.style.display = "none";
+      modal.classList.remove("active");
+    }
+  }
+};
+window.checkDocumentsVisibility = async function() {
+  const docBtn = document.getElementById("documentsOption");
+  const docDivider = document.getElementById("documentsDivider");
+  const hasDocs = await hasDocuments();
+  docBtn.style.display = hasDocs ? "block" : "none";
+  if (docDivider) docDivider.style.display = hasDocs ? "block" : "none";
+  if (typeof window.checkMoreButtonVisibility === "function") {
+    window.checkMoreButtonVisibility();
+  }
+};
+window.insertAppDocument = async function(doc) {
+  try {
+    await insertDocument(doc);
+    console.log("Document inserted");
+    await window.checkDocumentsVisibility();
+    return true;
+  } catch (e) {
+    console.error("Failed to insert document", e);
+    return false;
+  }
+};
+window.deleteAppDocument = async function(id) {
+  try {
+    await deleteDocument(id);
+    console.log("Document deleted");
+    await window.checkDocumentsVisibility();
+    return true;
+  } catch (e) {
+    console.error("Failed to delete document", e);
+    return false;
+  }
+};
+window.getAllDocuments = getAllDocuments;
+window.hasDocuments = hasDocuments;
 export {
   loadUnviredForms
 };