@zestl/zvolv-widgets 0.0.0 → 0.0.2

package/dist/index.cjs

@@ -1,28 +1,30 @@
 'use strict';
 
-var React13 = require('react');
+var React14 = require('react');
 var jsxRuntime = require('react/jsx-runtime');
-var dayjs8 = require('dayjs');
+var dayjs4 = require('dayjs');
 var utc = require('dayjs/plugin/utc.js');
 var weekOfYear = require('dayjs/plugin/weekOfYear.js');
 var _ = require('lodash');
+var timezone2 = require('dayjs/plugin/timezone.js');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
-var React13__default = /*#__PURE__*/_interopDefault(React13);
-var dayjs8__default = /*#__PURE__*/_interopDefault(dayjs8);
+var React14__default = /*#__PURE__*/_interopDefault(React14);
+var dayjs4__default = /*#__PURE__*/_interopDefault(dayjs4);
 var utc__default = /*#__PURE__*/_interopDefault(utc);
 var weekOfYear__default = /*#__PURE__*/_interopDefault(weekOfYear);
 var ___default = /*#__PURE__*/_interopDefault(_);
+var timezone2__default = /*#__PURE__*/_interopDefault(timezone2);
 
 // src/core/ZvolvProvider.tsx
-var RuntimeContext = React13.createContext(null);
+var RuntimeContext = React14.createContext(null);
 var ZvolvProvider = ({ runtime, children }) => {
-  const value = React13.useMemo(() => runtime, [runtime]);
+  const value = React14.useMemo(() => runtime, [runtime]);
   return /* @__PURE__ */ jsxRuntime.jsx(RuntimeContext.Provider, { value, children });
 };
 function useZvolvRuntime() {
-  const ctx = React13.useContext(RuntimeContext);
+  const ctx = React14.useContext(RuntimeContext);
   if (!ctx) {
     throw new Error(
       "@zestl/zvolv-widgets: no ZvolvProvider found. Wrap your app in <ZvolvProvider runtime={...}> before rendering widgets or calling data hooks."
@@ -46,9 +48,47 @@ function getRuntimeClient() {
   if (!c) throw new Error("@zestl/zvolv-widgets: runtime client not set \u2014 use createZvolvRuntime({ client })");
   return c;
 }
+var sdk = {};
+try {
+  import('@zestl/zvolv-js-sdk').then((m) => {
+    sdk = m ?? {};
+  }).catch(() => {
+  });
+} catch {
+}
+var AUTH_CRYPT_READY = "zvAuthCryptReady";
+var isEnc = (v) => typeof v === "string" && v.startsWith("enc::");
+var hasEnc = (node) => Array.isArray(node) ? node.some(hasEnc) : node && typeof node === "object" ? Object.values(node).some(hasEnc) : isEnc(node);
+function stripUndecrypted(node) {
+  if (Array.isArray(node)) return node.map(stripUndecrypted);
+  if (node && typeof node === "object") {
+    const out = {};
+    for (const [k, v] of Object.entries(node)) {
+      if (v && typeof v === "object") out[k] = stripUndecrypted(v);
+      else if (!isEnc(v)) out[k] = v;
+    }
+    return out;
+  }
+  return isEnc(node) ? void 0 : node;
+}
 function getStoredUser() {
   try {
-    return userReader() ?? clientGetter()?.auth?.userInstance ?? null;
+    let u = userReader() ?? null;
+    if (!u) {
+      try {
+        u = sdk.readUserFromStorage?.() ?? null;
+      } catch {
+        u = null;
+      }
+    }
+    if (!u) u = clientGetter()?.auth?.userInstance ?? null;
+    if (u && hasEnc(u) && typeof sdk.decryptAuthObject === "function") {
+      try {
+        u = sdk.decryptAuthObject(u);
+      } catch {
+      }
+    }
+    return u ? stripUndecrypted(u) : null;
   } catch {
     return null;
   }
@@ -89,8 +129,8 @@ var TASK_DATE_FIELDS = [
   "completeDate"
 ];
 new Set(TASK_DATE_FIELDS.map((f) => f.toLowerCase()));
-dayjs8__default.default.extend(utc__default.default);
-dayjs8__default.default.extend(weekOfYear__default.default);
+dayjs4__default.default.extend(utc__default.default);
+dayjs4__default.default.extend(weekOfYear__default.default);
 function humanizeDurationToMinutes(value) {
   if (!value) return 0;
   let total = 0;
@@ -134,60 +174,60 @@ function getDataType(elementType) {
 }
 function getDateRange(ops) {
   const values = [];
-  const fmt = "YYYY-MM-DD";
-  const today = dayjs8__default.default();
+  const fmt2 = "YYYY-MM-DD";
+  const today = dayjs4__default.default();
   switch (ops) {
     case "TODAY":
-      values[0] = today.format(fmt);
-      values[1] = today.format(fmt);
+      values[0] = today.format(fmt2);
+      values[1] = today.format(fmt2);
       break;
     case "LAST_SEVEN_DAYS":
-      values[0] = today.subtract(7, "day").format(fmt);
-      values[1] = today.add(1, "day").format(fmt);
+      values[0] = today.subtract(7, "day").format(fmt2);
+      values[1] = today.add(1, "day").format(fmt2);
       break;
     case "LAST_THIRTY_DAYS":
-      values[0] = today.subtract(30, "day").format(fmt);
-      values[1] = today.add(1, "day").format(fmt);
+      values[0] = today.subtract(30, "day").format(fmt2);
+      values[1] = today.add(1, "day").format(fmt2);
       break;
     case "THIS_WEEK":
-      values[0] = today.startOf("week").format(fmt);
-      values[1] = today.endOf("week").format(fmt);
+      values[0] = today.startOf("week").format(fmt2);
+      values[1] = today.endOf("week").format(fmt2);
       break;
     case "THIS_MONTH":
-      values[0] = today.startOf("month").format(fmt);
-      values[1] = today.endOf("month").format(fmt);
+      values[0] = today.startOf("month").format(fmt2);
+      values[1] = today.endOf("month").format(fmt2);
       break;
     case "THIS_YEAR":
-      values[0] = today.startOf("year").format(fmt);
-      values[1] = today.endOf("year").format(fmt);
+      values[0] = today.startOf("year").format(fmt2);
+      values[1] = today.endOf("year").format(fmt2);
       break;
     case "THIS_FINANCIAL_YEAR": {
       const m = today.month();
       const fiscalStart = m < 3 ? today.subtract(1, "year").month(3).date(1) : today.month(3).date(1);
       const fiscalEnd = m < 3 ? today.month(2).date(31) : today.add(1, "year").month(2).date(31);
-      values[0] = fiscalStart.format(fmt);
-      values[1] = fiscalEnd.format(fmt);
+      values[0] = fiscalStart.format(fmt2);
+      values[1] = fiscalEnd.format(fmt2);
       break;
     }
     case "NEXT_THREE_DAYS":
-      values[0] = today.format(fmt);
-      values[1] = today.add(4, "day").format(fmt);
+      values[0] = today.format(fmt2);
+      values[1] = today.add(4, "day").format(fmt2);
       break;
     case "NEXT_SEVEN_DAYS":
-      values[0] = today.format(fmt);
-      values[1] = today.add(8, "day").format(fmt);
+      values[0] = today.format(fmt2);
+      values[1] = today.add(8, "day").format(fmt2);
       break;
     case "NEXT_WEEK":
-      values[0] = today.add(1, "week").startOf("week").format(fmt);
-      values[1] = today.add(1, "week").endOf("week").format(fmt);
+      values[0] = today.add(1, "week").startOf("week").format(fmt2);
+      values[1] = today.add(1, "week").endOf("week").format(fmt2);
       break;
     case "NEXT_FIFTEEN_DAYS":
-      values[0] = today.format(fmt);
-      values[1] = today.add(16, "day").format(fmt);
+      values[0] = today.format(fmt2);
+      values[1] = today.add(16, "day").format(fmt2);
       break;
     case "NEXT_THIRTY_DAYS":
-      values[0] = today.format(fmt);
-      values[1] = today.add(30, "day").format(fmt);
+      values[0] = today.format(fmt2);
+      values[1] = today.add(30, "day").format(fmt2);
       break;
     case "THIS_QUARTER": {
       const m = today.month();
@@ -205,8 +245,8 @@ function getDateRange(ops) {
         qStart = today.startOf("year").month(9).date(1);
         qEnd = today.startOf("year").month(11).date(31);
       }
-      values[0] = qStart.format(fmt);
-      values[1] = qEnd.format(fmt);
+      values[0] = qStart.format(fmt2);
+      values[1] = qEnd.format(fmt2);
       break;
     }
   }
@@ -287,7 +327,7 @@ var resolveQueryUser = () => {
 };
 
 // src/runtime/queryGenerator.ts
-dayjs8__default.default.extend(utc__default.default);
+dayjs4__default.default.extend(utc__default.default);
 var mappingsCache = /* @__PURE__ */ new Map();
 function getCachedAnalyticsMappings(indexKey) {
   let pending2 = mappingsCache.get(indexKey);
@@ -439,7 +479,7 @@ function resolveDateMath(value) {
   if (typeof value !== "string") return null;
   const match = dateMathPattern.exec(value.trim());
   if (!match) return null;
-  let d = dayjs8__default.default();
+  let d = dayjs4__default.default();
   const [, amountStr, amountUnit, , roundUnit] = match;
   if (amountStr && amountUnit) {
     d = d.add(parseInt(amountStr, 10), dateMathUnit[amountUnit]);
@@ -453,56 +493,56 @@ function isDateMath(value) {
   return typeof value === "string" && dateMathPattern.test(value.trim());
 }
 function getDate(dateFormula) {
-  const fmt = "YYYY-MM-DDTHH:mm:ssZ";
-  const d = dayjs8__default.default();
+  const fmt2 = "YYYY-MM-DDTHH:mm:ssZ";
+  const d = dayjs4__default.default();
   switch (dateFormula) {
     case "{@[TODAY]}":
-      return d.startOf("day").format(fmt);
+      return d.startOf("day").format(fmt2);
     case "{@[3DAYSLATER]}":
-      return d.add(3, "day").startOf("day").format(fmt);
+      return d.add(3, "day").startOf("day").format(fmt2);
     case "{@[7DAYSLATER]}":
-      return d.add(7, "day").startOf("day").format(fmt);
+      return d.add(7, "day").startOf("day").format(fmt2);
     case "{@[14DAYSLATER]}":
-      return d.add(14, "day").startOf("day").format(fmt);
+      return d.add(14, "day").startOf("day").format(fmt2);
     case "{@[15DAYSLATER]}":
-      return d.add(15, "day").startOf("day").format(fmt);
+      return d.add(15, "day").startOf("day").format(fmt2);
     case "{@[21DAYSLATER]}":
-      return d.add(21, "day").startOf("day").format(fmt);
+      return d.add(21, "day").startOf("day").format(fmt2);
     case "{@[28DAYSLATER]}":
-      return d.add(28, "day").startOf("day").format(fmt);
+      return d.add(28, "day").startOf("day").format(fmt2);
     case "{@[30DAYSLATER]}":
-      return d.add(30, "day").startOf("day").format(fmt);
+      return d.add(30, "day").startOf("day").format(fmt2);
     case "{@[60DAYSLATER]}":
-      return d.add(60, "day").startOf("day").format(fmt);
+      return d.add(60, "day").startOf("day").format(fmt2);
     case "{@[90DAYSLATER]}":
-      return d.add(90, "day").startOf("day").format(fmt);
+      return d.add(90, "day").startOf("day").format(fmt2);
     case "{@[180DAYSLATER]}":
-      return d.add(180, "day").startOf("day").format(fmt);
+      return d.add(180, "day").startOf("day").format(fmt2);
     case "{@[365DAYSLATER]}":
-      return d.add(365, "day").startOf("day").format(fmt);
+      return d.add(365, "day").startOf("day").format(fmt2);
     case "{@[3DAYSAGO]}":
-      return d.subtract(3, "day").startOf("day").format(fmt);
+      return d.subtract(3, "day").startOf("day").format(fmt2);
     case "{@[7DAYSAGO]}":
-      return d.subtract(7, "day").startOf("day").format(fmt);
+      return d.subtract(7, "day").startOf("day").format(fmt2);
     case "{@[14DAYSAGO]}":
-      return d.subtract(14, "day").startOf("day").format(fmt);
+      return d.subtract(14, "day").startOf("day").format(fmt2);
     case "{@[15DAYSAGO]}":
-      return d.subtract(15, "day").startOf("day").format(fmt);
+      return d.subtract(15, "day").startOf("day").format(fmt2);
     case "{@[21DAYSAGO]}":
-      return d.subtract(21, "day").startOf("day").format(fmt);
+      return d.subtract(21, "day").startOf("day").format(fmt2);
     case "{@[28DAYSAGO]}":
-      return d.subtract(28, "day").startOf("day").format(fmt);
+      return d.subtract(28, "day").startOf("day").format(fmt2);
     case "{@[30DAYSAGO]}":
-      return d.subtract(20, "day").startOf("day").format(fmt);
+      return d.subtract(20, "day").startOf("day").format(fmt2);
     // note: original uses 20
     case "{@[60DAYSAGO]}":
-      return d.subtract(60, "day").startOf("day").format(fmt);
+      return d.subtract(60, "day").startOf("day").format(fmt2);
     case "{@[90DAYSAGO]}":
-      return d.subtract(90, "day").startOf("day").format(fmt);
+      return d.subtract(90, "day").startOf("day").format(fmt2);
     case "{@[180DAYSAGO]}":
-      return d.subtract(180, "day").startOf("day").format(fmt);
+      return d.subtract(180, "day").startOf("day").format(fmt2);
     case "{@[365DAYSAGO]}":
-      return d.subtract(365, "day").startOf("day").format(fmt);
+      return d.subtract(365, "day").startOf("day").format(fmt2);
     default:
       return dateFormula;
   }
@@ -582,8 +622,8 @@ function getFormula(formula, fMap, isFilter = false) {
           }
         }
       });
-      formula.format.split("%s").forEach((text, i) => {
-        textFormat += i === 0 ? `'${text}'` : ` + '${text}'`;
+      formula.format.split("%s").forEach((text2, i) => {
+        textFormat += i === 0 ? `'${text2}'` : ` + '${text2}'`;
         if (textOperands[i]) textFormat += ` + ${textOperands[i]} `;
       });
       script = { script: `if( ${str} ) { return '' } else { return ${textFormat}}` };
@@ -651,7 +691,7 @@ function getFilters(field2, type, loggedInUser = null, isTask = false) {
     field2.filter.operand = field2.filter.operand.map((oprd) => {
       if (isDateMath(oprd)) return oprd;
       const pattern = dateFieldPattern[field2.fieldFormat] ?? field2.fieldFormat;
-      return dayjs8__default.default(oprd, pattern).format("YYYY-MM-DD");
+      return dayjs4__default.default(oprd, pattern).format("YYYY-MM-DD");
     });
   }
   if (field2["taskfield"] && !field2["masterFieldDataType"]) {
@@ -936,6 +976,142 @@ function getTaskElementSort(dataSource, fieldMetaByName) {
   }
   return null;
 }
+function pivotEsField(entry) {
+  return entry?.masterField || entry?.title;
+}
+var HISTOGRAM_INTERVALS = {
+  day: "1d",
+  week: "1w",
+  month: "1M",
+  quarter: "1q",
+  year: "1y"
+};
+function getDateHistogramSource(row, esField, mfType, meta, sortOrder) {
+  const isTaskDate = taskDate.includes(esField) && !!(row.isTaskField || row.taskfield || meta?.isTaskField || meta?.taskfield);
+  if (!dateTypes.includes(mfType) && !isTaskDate) {
+    console.warn(`[@zestl/zvolv-widgets] groupBy "${row.title}": interval "${row.interval}" ignored \u2014 "${esField}" is not a date field.`);
+    return null;
+  }
+  const calendarInterval = HISTOGRAM_INTERVALS[row.interval];
+  if (!calendarInterval) {
+    console.warn(`[@zestl/zvolv-widgets] groupBy "${row.title}": unknown interval "${row.interval}" \u2014 use day | week | month | quarter | year.`);
+    return null;
+  }
+  const histogram = { field: esField, calendar_interval: calendarInterval, time_zone: row.timeZone || timezone };
+  if (sortOrder) histogram.order = sortOrder;
+  return { date_histogram: histogram };
+}
+var summaryFilterLists = /* @__PURE__ */ new Map();
+var DATE_DIFF_DIVISOR = {
+  days: "86400000.0",
+  hours: "3600000.0",
+  minutes: "60000.0"
+};
+var LITERAL_DATE = /^\d{4}-\d{2}-\d{2}([T ][\d:.]+(Z|[+-]\d{2}:?\d{2})?)?$/;
+function getDateDiffFixedEnd(end) {
+  if (typeof end !== "string") return null;
+  if (dateFormulas.includes(end)) return dayjs4__default.default(getDate(end)).valueOf();
+  if (LITERAL_DATE.test(end.trim())) {
+    const d = dayjs4__default.default(end.trim());
+    if (d.isValid()) return d.valueOf();
+  }
+  if (/^\{@\[.*\]\}$/.test(end)) {
+    console.warn(`[@zestl/zvolv-widgets] dateDiff end "${end}" is not a known date token (${dateFormulas.join(", ")}); it is being queried as a field name.`);
+  }
+  return null;
+}
+function getDateDiffScript(dd, fixedEnd) {
+  const divisor = DATE_DIFF_DIVISOR[dd.unit] ?? DATE_DIFF_DIVISOR.days;
+  if (fixedEnd != null) {
+    return {
+      source: `if(doc['${dd.start}'].size()==0) { return null; } return (params.now - doc['${dd.start}'].value.millis) / ${divisor};`,
+      lang: "painless",
+      params: { now: fixedEnd }
+    };
+  }
+  return {
+    source: `if(doc['${dd.start}'].size()==0 || doc['${dd.end}'].size()==0) { return null; } return (doc['${dd.end}'].value.millis - doc['${dd.start}'].value.millis) / ${divisor};`,
+    lang: "painless"
+  };
+}
+function getSummaryFilterClause(sumary, f, loggedInUser) {
+  if (f.operator === "_ALL" || f.operator === "MULTIPLE") return null;
+  const fb = {
+    header: sumary.title,
+    masterfield: f.operand ?? f.masterField,
+    masterFieldDataType: f.masterFieldDataType,
+    masterFieldType: f.masterFieldType,
+    filter: { operator: f.operator, operand: Array.isArray(f.value) ? [...f.value] : f.value }
+  };
+  return getFilters(fb, "PIVOT", loggedInUser) ?? null;
+}
+function buildExtendedSummary(sumary, summaryAggs, loggedInUser, sortKeys = {}) {
+  const name = sumary.value;
+  const list = summaryFilterLists.get(name) ?? [];
+  const andGroup = list.length > 1 && list.some((f) => f?.combine === "AND");
+  const isPercentiles = sumary.type === "percentiles";
+  if (!sumary.dateDiff && !andGroup && !(isPercentiles && sumary.percents?.length)) return false;
+  const must = [];
+  const mustNot = [];
+  const conditions = andGroup ? list : list.slice(-1);
+  for (const f of conditions) {
+    const clause = getSummaryFilterClause(sumary, f, loggedInUser);
+    if (!clause) continue;
+    if (mustNotOp.includes(f.operator)) mustNot.push({ ...clause });
+    else must.push(clause);
+  }
+  let metric;
+  if (sumary.dateDiff) {
+    const dd = sumary.dateDiff;
+    const fixedEnd = getDateDiffFixedEnd(dd.end);
+    must.push({ exists: { field: dd.start } });
+    if (fixedEnd == null) must.push({ exists: { field: dd.end } });
+    metric = { script: getDateDiffScript(dd, fixedEnd) };
+  } else {
+    const esField = pivotEsField(sumary);
+    let aggType = sumary.type;
+    let aggField = esField;
+    const isTextField = sumary.masterFieldDataType === "STRING" && !dateTypes.includes(sumary.masterFieldType) && !isNumericTaskField(sumary);
+    if (sumary.masterFieldType === "FORM_SEARCH" && (aggType === "value_count" || aggType === "cardinality")) {
+      aggField = resolveFormSearchViewField(esField);
+    } else if (sumary.masterFieldType === "FILE_UPLOAD_V2") {
+      aggField = `${esField}.mediaKey.keyword`;
+    } else if (isTextField) {
+      if (["sum", "avg", "min", "max"].includes(aggType)) aggType = "value_count";
+      aggField = `${esField}.keyword`;
+    }
+    metric = { field: aggField };
+    finish(name, summaryAggs, must, mustNot, { [aggType]: metric });
+    if (isPercentiles && sumary.percents?.length) metric.percents = sumary.percents;
+    if (!isPercentiles && aggField === esField && sortKeys[esField]) {
+      summaryAggs[`${name}_sort`] = { bucket_sort: { sort: [{ [name]: { order: sortKeys[esField] } }] } };
+    }
+    return true;
+  }
+  if (isPercentiles && sumary.percents?.length) metric.percents = sumary.percents;
+  return finish(name, summaryAggs, must, mustNot, { [sumary.type]: metric });
+}
+function finish(name, summaryAggs, must, mustNot, metric) {
+  if (must.length === 0 && mustNot.length === 0) {
+    summaryAggs[name] = metric;
+    return true;
+  }
+  const bool = {};
+  if (must.length) bool.must = must;
+  if (mustNot.length) bool.must_not = mustNot;
+  summaryAggs[name] = { filter: { bool }, aggs: { [name]: metric } };
+  return true;
+}
+function groupPivotFilters(pivotFilters) {
+  const out = /* @__PURE__ */ new Map();
+  (pivotFilters || []).forEach((f) => {
+    if (!f) return;
+    const list = out.get(f.field) ?? [];
+    list.push(f);
+    out.set(f.field, list);
+  });
+  return out;
+}
 function getCompositeAggregations(pivotBody, filterMap, aggDataPoints, size = 5e4, scriptFields = {}, loggedInUser = null, sort = [], fieldMetaByName) {
   const composite = { size, sources: [] };
   pivotBody.rows.forEach((row) => {
@@ -957,17 +1133,21 @@ function getCompositeAggregations(pivotBody, filterMap, aggDataPoints, size = 5e
     const meta = fieldMetaByName?.get(row.title) || fieldMetaByName?.get(row.masterField) || {};
     const mfType = row.masterFieldType ?? meta.masterFieldType;
     const mfDataType = row.masterFieldDataType ?? meta.masterFieldDataType ?? (mfType ? getDataType(mfType) : void 0);
+    const esField = pivotEsField(row);
     const sourceObj = {};
-    if (mfType === "FORM_SEARCH" || mfType === "INPUT_TAG") {
-      sourceObj[row.title] = { terms: { field: resolveFormSearchViewField(row.title) } };
+    const histogram = row.interval ? getDateHistogramSource(row, esField, mfType, meta, sortOrder) : null;
+    if (histogram) {
+      sourceObj[row.title] = histogram;
+    } else if (mfType === "FORM_SEARCH" || mfType === "INPUT_TAG") {
+      sourceObj[row.title] = { terms: { field: resolveFormSearchViewField(esField) } };
     } else if (mfType === "FILE_UPLOAD_V2") {
-      sourceObj[row.title] = { terms: { field: `${row.title}.mediaKey.keyword` } };
+      sourceObj[row.title] = { terms: { field: `${esField}.mediaKey.keyword` } };
     } else if (mfDataType === "STRING" && !dateTypes.includes(mfType) && !isNumericTaskField(row, fieldMetaByName)) {
-      sourceObj[row.title] = { terms: { field: `${row.title}.keyword` } };
+      sourceObj[row.title] = { terms: { field: `${esField}.keyword` } };
     } else if (!mfDataType && Object.keys(scriptFields).length > 0) {
       sourceObj[row.title] = { terms: scriptFields[row.title] };
     } else {
-      sourceObj[row.title] = { terms: { field: row.title } };
+      sourceObj[row.title] = { terms: { field: esField } };
       if (sortOrder) sourceObj[row.title]["terms"]["order"] = sortOrder;
     }
     composite.sources.push(sourceObj);
@@ -985,7 +1165,7 @@ function getColumnAggregations(pivotBody, filterMap, aggDataPoints, loggedInUser
       const colFilter = getFilters(fb, "PIVOT", loggedInUser);
       if (colFilter) colFilters.push(colFilter);
     }
-    colAggs[col.title] = { terms: { field: col.title } };
+    colAggs[col.title] = { terms: { field: pivotEsField(col) } };
     if (i === pivotBody.columns.length - 1) {
       const summaryResult = getSummaryAggregations(pivotBody, filterMap, aggDataPoints, loggedInUser, fMap);
       colAggs[col.title]["aggs"] = summaryResult.summaryAggs;
@@ -1018,6 +1198,7 @@ function getSummaryAggregations(pivotBody, filterMap, aggDataPoints, loggedInUse
   pivotBody.summary.forEach((sumary) => {
     const filter = filterMap.get(sumary.value);
     aggDataPoints["summary"].push(sumary.value);
+    if (buildExtendedSummary(sumary, summaryAggs, loggedInUser, sortKeys)) return;
     summaryAggs[sumary.value] = {};
     const addBucketSort = (key) => {
       if (sortKeys[key]) {
@@ -1025,17 +1206,18 @@ function getSummaryAggregations(pivotBody, filterMap, aggDataPoints, loggedInUse
       }
     };
     const isTextField = sumary.masterFieldDataType === "STRING" && !dateTypes.includes(sumary.masterFieldType) && !isNumericTaskField(sumary, fMap);
+    const esField = pivotEsField(sumary);
     let aggType = sumary.type;
-    let aggField = sumary.title;
+    let aggField = esField;
     if (sumary.masterFieldType === "FORM_SEARCH" && (sumary.type === "value_count" || sumary.type === "cardinality")) {
-      aggField = resolveFormSearchViewField(sumary.title);
+      aggField = resolveFormSearchViewField(esField);
     } else if (sumary.masterFieldType === "FILE_UPLOAD_V2") {
-      aggField = `${sumary.title}.mediaKey.keyword`;
+      aggField = `${esField}.mediaKey.keyword`;
     } else if (isTextField) {
       if (["sum", "avg", "min", "max"].includes(sumary.type)) aggType = "value_count";
-      aggField = `${sumary.title}.keyword`;
+      aggField = `${esField}.keyword`;
     }
-    const usesRawField = aggField === sumary.title;
+    const usesRawField = aggField === esField;
     if (filter) {
       const fb = {
         header: sumary.title,
@@ -1053,10 +1235,10 @@ function getSummaryAggregations(pivotBody, filterMap, aggDataPoints, loggedInUse
       }
       summaryAggs[sumary.value]["aggs"] = { [sumary.value]: {} };
       summaryAggs[sumary.value]["aggs"][sumary.value][aggType] = { field: aggField };
-      if (usesRawField) addBucketSort(sumary.title);
+      if (usesRawField) addBucketSort(esField);
     } else {
       summaryAggs[sumary.value][aggType] = { field: aggField };
-      if (usesRawField) addBucketSort(sumary.title);
+      if (usesRawField) addBucketSort(esField);
     }
   });
   return { summaryAggs, aggDataPoints };
@@ -1066,6 +1248,7 @@ function generateQuery(configuration, dataSource, formId, skip = null, limit = n
   scriptFilters = [];
   fieldMap = /* @__PURE__ */ new Map();
   currentMappings = mappings;
+  summaryFilterLists = /* @__PURE__ */ new Map();
   let staticQueryClause = null;
   const rawDataSourceQuery = dataSource?.query;
   if (rawDataSourceQuery && typeof rawDataSourceQuery === "string") {
@@ -1158,6 +1341,7 @@ function generateQuery(configuration, dataSource, formId, skip = null, limit = n
       if (dataSource?.pivot.filters?.length > 0) {
         dataSource?.pivot.filters.forEach((f) => filterMap2.set(f.field, f));
       }
+      summaryFilterLists = groupPivotFilters(dataSource?.pivot.filters);
       if (!isDrilldownView() && dataSource?.displayRowLimit && dataSource?.displayRowLimit !== "") {
         size = dataSource?.displayRowLimit;
       }
@@ -1665,7 +1849,7 @@ var resolveUserLabels = async (values, kind) => {
 // src/runtime/index.ts
 function createZvolvRuntime({ client, readUser }) {
   const getClient = typeof client === "function" ? client : () => client;
-  setRuntimeClient(getClient, readUser ?? (() => getClient()?.auth?.userInstance));
+  setRuntimeClient(getClient, readUser ?? (() => null));
   resetQueryUser();
   return {
     get client() {
@@ -1735,16 +1919,29 @@ function taskField(header, masterFieldType = "INPUT_TEXT", options = {}) {
     ...options
   };
 }
-function groupBy(f, title = f.header) {
+function groupBy(f, title = f.header, options = {}) {
   return {
     title,
     masterField: f.masterfield ?? f.taskfield ?? f.header,
     masterFieldType: f.masterFieldType,
-    masterFieldDataType: f.masterFieldDataType
+    masterFieldDataType: f.masterFieldDataType,
+    ...options.interval ? { interval: options.interval } : {},
+    ...options.timeZone ? { timeZone: options.timeZone } : {}
   };
 }
-function aggregate(f, type = "sum", outputName = f.header) {
+function dateDiff(start, end, unit = "days") {
+  const startField = start.masterfield ?? start.taskfield ?? start.header;
+  const endField = typeof end === "string" ? end === "TODAY" ? "{@[TODAY]}" : end : end.masterfield ?? end.taskfield ?? end.header;
+  const endLabel = typeof end === "string" ? end : end.header;
   return {
+    header: `${start.header} \u2192 ${endLabel} (${unit})`,
+    masterfield: startField,
+    masterFieldDataType: "FLOAT",
+    dateDiff: { start: startField, end: endField, unit }
+  };
+}
+function aggregate(f, type = "sum", outputName = f.header, options = {}) {
+  const summary = {
     title: f.header,
     masterField: f.masterfield ?? f.taskfield ?? f.header,
     masterFieldType: f.masterFieldType,
@@ -1752,6 +1949,36 @@ function aggregate(f, type = "sum", outputName = f.header) {
     value: outputName,
     type
   };
+  const dd = f.dateDiff;
+  if (dd) summary.dateDiff = { ...dd };
+  if (options.percents?.length) summary.percents = [...options.percents];
+  if (options.where?.length) {
+    summary.filters = options.where.map(([wf, cond]) => {
+      const mf = wf.masterfield ?? wf.taskfield ?? wf.header;
+      return {
+        field: outputName,
+        operand: mf,
+        masterField: mf,
+        masterFieldType: wf.masterFieldType,
+        masterFieldDataType: wf.masterFieldDataType,
+        operator: cond.operator,
+        value: [...cond.operand],
+        combine: "AND"
+      };
+    });
+  }
+  return summary;
+}
+function hoistSummaryFilters(p) {
+  if (!p?.summary?.some((s) => s.filters?.length)) return p;
+  const hoisted = [];
+  const summary = p.summary.map((s) => {
+    if (!s.filters) return s;
+    const { filters: filters2, ...rest } = s;
+    hoisted.push(...filters2);
+    return rest;
+  });
+  return { ...p, summary, filters: [...p.filters ?? [], ...hoisted] };
 }
 function derive(title, operator, operands) {
   return { title, operator, operands };
@@ -1764,7 +1991,7 @@ function formSource(formId, fields, options = {}) {
     formId,
     newFormFramework: true,
     fields: fields.map((f) => ({ ...f, formID: f.formID ?? formId })),
-    ...options.pivot ? { pivot: options.pivot } : {},
+    ...options.pivot ? { pivot: hoistSummaryFilters(options.pivot) } : {},
     ...options.displayRowLimit ? { displayRowLimit: options.displayRowLimit } : {}
   };
 }
@@ -1773,7 +2000,7 @@ function taskSource(fields, options = {}) {
     isTask: true,
     newFormFramework: true,
     fields: fields.map((f) => ({ ...f, isTaskField: true })),
-    ...options.pivot ? { pivot: options.pivot } : {},
+    ...options.pivot ? { pivot: hoistSummaryFilters(options.pivot) } : {},
     ...options.displayRowLimit ? { displayRowLimit: options.displayRowLimit } : {}
   };
 }
@@ -1781,13 +2008,13 @@ function automationSource(automationId, fields = []) {
   return { automation: { automationId, enabled: true }, fields };
 }
 function pivot(config) {
-  return {
+  return hoistSummaryFilters({
     rows: config.rows ?? [],
     columns: config.columns ?? [],
     summary: config.summary ?? [],
     filters: config.filters ?? [],
     postOperations: config.postOperations ?? []
-  };
+  });
 }
 
 // src/core/config.ts
@@ -1885,7 +2112,7 @@ function coerceForField(field2, values) {
   });
 }
 var FMT = "YYYY-MM-DD";
-function resolveDateToken(token, now = dayjs8__default.default()) {
+function resolveDateToken(token, now = dayjs4__default.default()) {
   switch (String(token).toUpperCase()) {
     case "TODAY":
       return [now.format(FMT), now.format(FMT)];
@@ -1908,19 +2135,19 @@ function resolveDateToken(token, now = dayjs8__default.default()) {
   }
 }
 var SEARCH_DATE_FORMATS = ["YYYY-MM-DD", "DD/MM/YYYY", "DD-MM-YYYY", "MM/DD/YYYY"];
-function searchAsDate(text) {
-  const t = text.trim();
+function searchAsDate(text2) {
+  const t = text2.trim();
   if (!/^\d{1,4}[-/]\d{1,2}[-/]\d{1,4}$/.test(t)) return null;
-  for (const fmt of SEARCH_DATE_FORMATS) {
-    const [y, m, d] = parseStrict(t, fmt);
+  for (const fmt2 of SEARCH_DATE_FORMATS) {
+    const [y, m, d] = parseStrict(t, fmt2);
     if (y) return `${y}-${m}-${d}`;
   }
   return null;
 }
-function parseStrict(text, fmt) {
-  const sep = fmt.includes("/") ? "/" : "-";
-  const parts = text.split(sep);
-  const order = fmt.split(sep);
+function parseStrict(text2, fmt2) {
+  const sep = fmt2.includes("/") ? "/" : "-";
+  const parts = text2.split(sep);
+  const order = fmt2.split(sep);
   if (parts.length !== 3 || order.length !== 3) return [null, null, null];
   const map = {};
   order.forEach((k, i) => {
@@ -1929,15 +2156,15 @@ function parseStrict(text, fmt) {
   const y = map.YYYY, m = map.MM, d = map.DD;
   if (!y || y.length !== 4 || !m || !d) return [null, null, null];
   const mm = m.padStart(2, "0"), dd = d.padStart(2, "0");
-  const parsed = dayjs8__default.default(`${y}-${mm}-${dd}`);
+  const parsed = dayjs4__default.default(`${y}-${mm}-${dd}`);
   if (!parsed.isValid() || parsed.format(FMT) !== `${y}-${mm}-${dd}`) return [null, null, null];
   return [y, mm, dd];
 }
 function buildSearchClause(search) {
-  const text = (search ?? "").trim();
-  if (!text) return null;
-  const iso = searchAsDate(text);
-  return iso ? { filter: { operator: "MULTIPLE", operand: iso } } : { filter: { operator: "_ALL", operand: text } };
+  const text2 = (search ?? "").trim();
+  if (!text2) return null;
+  const iso = searchAsDate(text2);
+  return iso ? { filter: { operator: "MULTIPLE", operand: iso } } : { filter: { operator: "_ALL", operand: text2 } };
 }
 function buildWidgetFilterClauses(dataSource, filters2 = []) {
   const isTask = resolveIsTask2(dataSource);
@@ -2028,7 +2255,7 @@ function toComparable(v) {
   if (typeof v === "number") return v;
   const n = Number(v);
   if (!isNaN(n)) return n;
-  const d = dayjs8__default.default(v);
+  const d = dayjs4__default.default(v);
   return d.isValid() ? d.valueOf() : null;
 }
 function applyLocalSearch(rows, search, toLabel) {
@@ -2096,7 +2323,7 @@ function matchesWidgetFilter(row, f) {
     case "DATE_IS": {
       const range = resolveDateToken(String(values[0] ?? ""));
       if (!range || raw2 == null || raw2 === "") return false;
-      const d = dayjs8__default.default(raw2).format(FMT);
+      const d = dayjs4__default.default(raw2).format(FMT);
       return d >= range[0] && d <= range[1];
     }
     default:
@@ -2300,22 +2527,22 @@ function resolveWidgetDefaults(tokens, widgetType, config) {
   const typeDefaults = widgetType && (defaults[widgetType] ?? defaults[widgetType.toUpperCase()]) || {};
   return { ...typeDefaults, ...config || {} };
 }
-var TokensContext = React13.createContext(defaultTokens);
+var TokensContext = React14.createContext(defaultTokens);
 var ZvolvThemeProvider = ({ tokens, children }) => {
-  const value = React13.useMemo(() => mergeTokens(defaultTokens, tokens), [tokens]);
+  const value = React14.useMemo(() => mergeTokens(defaultTokens, tokens), [tokens]);
   return /* @__PURE__ */ jsxRuntime.jsx(TokensContext.Provider, { value, children });
 };
 function useTokens() {
-  return React13.useContext(TokensContext);
+  return React14.useContext(TokensContext);
 }
-var TemplateContext = React13.createContext({});
+var TemplateContext = React14.createContext({});
 var TemplateProvider = ({ templates, children }) => {
-  const parent = React13.useContext(TemplateContext);
-  const value = React13.useMemo(() => ({ ...parent, ...templates || {} }), [parent, templates]);
+  const parent = React14.useContext(TemplateContext);
+  const value = React14.useMemo(() => ({ ...parent, ...templates || {} }), [parent, templates]);
   return /* @__PURE__ */ jsxRuntime.jsx(TemplateContext.Provider, { value, children });
 };
 function useTemplateOverride(widgetType, templateId) {
-  const map = React13.useContext(TemplateContext);
+  const map = React14.useContext(TemplateContext);
   return map[`${widgetType}:${templateId}`] ?? map[`${widgetType}:*`] ?? null;
 }
 var Label = ({ children }) => {
@@ -2348,11 +2575,11 @@ var Delta = ({ vm }) => {
   if (!vm.delta) return null;
   const color = vm.delta.isPositive ? t.colors.success : t.colors.error;
   const sign = vm.delta.value >= 0 ? "+" : "";
-  const text = vm.delta.mode === "percent" ? `${sign}${vm.delta.value.toFixed(1)}%` : `${sign}${vm.delta.value}`;
+  const text2 = vm.delta.mode === "percent" ? `${sign}${vm.delta.value.toFixed(1)}%` : `${sign}${vm.delta.value}`;
   return /* @__PURE__ */ jsxRuntime.jsxs("span", { style: { color, fontSize: "12px", fontWeight: 600 }, children: [
     vm.delta.isPositive ? "\u25B2" : "\u25BC",
     " ",
-    text
+    text2
   ] });
 };
 var Sparkline = ({
@@ -2515,7 +2742,7 @@ var KPI_DEFAULT_TEMPLATES = {
   hero_chart: HeroChart,
   icon: Icon
 };
-var WidgetStateSlot = React13__default.default.createContext(null);
+var WidgetStateSlot = React14__default.default.createContext(null);
 var WidgetShell = ({
   widgetType,
   title,
@@ -2533,7 +2760,7 @@ var WidgetShell = ({
 }) => {
   const t = useTokens();
   const chrome = resolveChrome(t, widgetType);
-  const renderState = React13__default.default.useContext(WidgetStateSlot);
+  const renderState = React14__default.default.useContext(WidgetStateSlot);
   const frame = {
     display: "flex",
     flexDirection: "column",
@@ -2638,24 +2865,91 @@ function alignSummaryToSeries(dataSource, series) {
   });
   return { ...dataSource, pivot: { ...dataSource.pivot, summary: fixedSummary } };
 }
+dayjs4__default.default.extend(utc__default.default);
+dayjs4__default.default.extend(timezone2__default.default);
 function isLikelyTimestamp(v) {
   if (typeof v !== "number" || !Number.isFinite(v)) return false;
   return v > 946e9 && v < 41e11;
 }
-function fillDateGaps({ rows, xKey, series, unit, range }) {
+function wallStartOfPeriod(d, unit) {
+  switch (unit) {
+    case "week": {
+      const day = d.startOf("day");
+      return day.subtract((day.day() + 6) % 7, "day");
+    }
+    case "quarter": {
+      const month = d.startOf("month");
+      return month.month(Math.floor(month.month() / 3) * 3);
+    }
+    default:
+      return d.startOf(unit);
+  }
+}
+function wallAddPeriod(d, unit) {
+  return unit === "quarter" ? d.add(3, "month") : d.add(1, unit);
+}
+function inZone(wall, d, timeZone) {
+  const date = wall(dayjs4__default.default.utc(d.tz(timeZone).format("YYYY-MM-DD"))).format("YYYY-MM-DD");
+  return dayjs4__default.default.tz(date, timeZone);
+}
+function startOfPeriod(d, unit, timeZone) {
+  return timeZone ? inZone((w) => wallStartOfPeriod(w, unit), d, timeZone) : wallStartOfPeriod(d, unit);
+}
+function addPeriod(d, unit, timeZone) {
+  return timeZone ? inZone((w) => wallAddPeriod(w, unit), d, timeZone) : wallAddPeriod(d, unit);
+}
+var HAS_OFFSET = /(Z|[+-]\d{2}:?\d{2})$/i;
+function parseDateValue(v, timeZone) {
+  if (timeZone && typeof v === "string" && !HAS_OFFSET.test(v.trim())) {
+    try {
+      return dayjs4__default.default.tz(v, timeZone);
+    } catch {
+      return dayjs4__default.default(NaN);
+    }
+  }
+  return dayjs4__default.default(v);
+}
+function sumInto(target, row, series) {
+  series.forEach(({ valueField }) => {
+    if (!(valueField in row) && !(valueField in target)) return;
+    const a = Number(target[valueField]);
+    const b = Number(row[valueField]);
+    target[valueField] = (Number.isFinite(a) ? a : 0) + (Number.isFinite(b) ? b : 0);
+  });
+}
+function fillDateGaps({
+  rows,
+  xKey,
+  series,
+  unit,
+  range,
+  merge = "sum",
+  xFormat,
+  timeZone
+}) {
   if (!range) return rows;
-  const keyFormat = unit === "month" ? "YYYY-MM" : "YYYY-MM-DD";
   const byPeriod = /* @__PURE__ */ new Map();
+  const copied = /* @__PURE__ */ new Set();
   rows.forEach((row) => {
-    const d = dayjs8__default.default(row[xKey]);
-    if (d.isValid()) byPeriod.set(d.startOf(unit).format(keyFormat), row);
+    const d = parseDateValue(row[xKey], timeZone);
+    if (!d.isValid()) return;
+    const key = startOfPeriod(d, unit, timeZone).valueOf();
+    const existing = byPeriod.get(key);
+    if (!existing || merge === "last") {
+      byPeriod.set(key, row);
+      return;
+    }
+    const merged = copied.has(key) ? existing : { ...existing };
+    copied.add(key);
+    sumInto(merged, row, series);
+    byPeriod.set(key, merged);
   });
   const filled = [];
-  let cursor = range.start;
-  const useTimestamp = isLikelyTimestamp(rows[0]?.[xKey]);
-  while (cursor.isBefore(range.end) || cursor.isSame(range.end, unit)) {
-    const key = cursor.format(keyFormat);
-    const existing = byPeriod.get(key);
+  const useTimestamp = rows.length ? isLikelyTimestamp(rows[0]?.[xKey]) : xFormat === "timestamp";
+  const end = startOfPeriod(range.end, unit, timeZone);
+  let cursor = startOfPeriod(range.start, unit, timeZone);
+  while (!cursor.isAfter(end)) {
+    const existing = byPeriod.get(cursor.valueOf());
     if (existing) {
       filled.push(existing);
     } else {
@@ -2667,10 +2961,33 @@ function fillDateGaps({ rows, xKey, series, unit, range }) {
       });
       filled.push(zeroRow);
     }
-    cursor = cursor.add(1, unit);
+    cursor = addPeriod(cursor, unit, timeZone);
   }
   return filled;
 }
+function applyCumulative(rows, xKey, fields, baseline = {}) {
+  if (!fields.length) return rows;
+  const dated = rows.map((row, i) => ({ row, i, t: dayjs4__default.default(row?.[xKey]).valueOf() }));
+  dated.sort((a, b) => {
+    const at = Number.isFinite(a.t), bt = Number.isFinite(b.t);
+    if (at && bt) return a.t - b.t || a.i - b.i;
+    if (at !== bt) return at ? -1 : 1;
+    return a.i - b.i;
+  });
+  const running = {};
+  fields.forEach((f) => {
+    running[f] = Number(baseline[f]) || 0;
+  });
+  return dated.map(({ row }) => {
+    const next = { ...row };
+    fields.forEach((f) => {
+      const v = Number(row?.[f]);
+      running[f] += Number.isFinite(v) ? v : 0;
+      next[f] = running[f];
+    });
+    return next;
+  });
+}
 function toNumber(v) {
   if (typeof v === "number") return Number.isFinite(v) ? v : 0;
   const n = Number(v);
@@ -2688,6 +3005,49 @@ function coerceSeriesNumbers(rows, series) {
   });
 }
 
+// src/transforms/percentiles.ts
+function percentileKey(name, percent) {
+  return `${name}_p${String(Number(percent)).replace(".", "_")}`;
+}
+function percentileSummaries(summary) {
+  return (summary || []).filter((s) => s?.type === "percentiles" && s.value).map((s) => s.value);
+}
+function readPercentiles(raw2) {
+  if (raw2 == null || typeof raw2 !== "object") return null;
+  const values = Array.isArray(raw2) ? raw2 : raw2.values ?? raw2;
+  const out = {};
+  if (Array.isArray(values)) {
+    values.forEach((v) => {
+      if (v && v.key != null) out[String(v.key)] = v.value;
+    });
+  } else if (typeof values === "object") {
+    for (const [k, v] of Object.entries(values)) {
+      if (k.endsWith("_as_string")) continue;
+      if (Number.isFinite(Number(k))) out[k] = v;
+    }
+  }
+  return Object.keys(out).length ? out : null;
+}
+function flattenPercentiles(rows, names) {
+  if (!names.length) return rows;
+  return rows.map((row) => {
+    let next = row;
+    for (const name of names) {
+      const parsed = readPercentiles(row?.[name]);
+      if (!parsed) continue;
+      if (next === row) next = { ...row };
+      let median;
+      for (const [percent, value] of Object.entries(parsed)) {
+        const n = value == null ? null : Number(value);
+        next[percentileKey(name, percent)] = n;
+        if (Number(percent) === 50 && n != null) median = n;
+      }
+      if (median !== void 0) next[name] = median;
+    }
+    return next;
+  });
+}
+
 // src/react/useWidgetData.ts
 var ALIGN_TYPES = /* @__PURE__ */ new Set(["BAR", "BAR_CHART", "PIE", "PIE_CHART", "DOUGHNUT", "DOUGHNUT_CHART"]);
 var formCache = /* @__PURE__ */ new WeakMap();
@@ -2708,9 +3068,30 @@ function getFormOnce(client, formId) {
   }
   return p;
 }
+function baselineClause(source, start) {
+  const f = (source.dataSource?.fields || []).find(
+    (x) => x?.header === source.dateField || x?.masterfield === source.dateField
+  );
+  return {
+    header: f?.header ?? source.dateField,
+    masterfield: f?.masterfield ?? source.dateField,
+    masterFieldType: f?.masterFieldType ?? "DATE_PICKER",
+    masterFieldDataType: f?.masterFieldDataType ?? "STRING",
+    // Date-only: the query generator keeps "YYYY-MM-DD" operands as dates.
+    filter: { operator: "LESS_THAN", operand: [start.format("YYYY-MM-DD")] }
+  };
+}
+function readBaseline(rows) {
+  const out = {};
+  for (const [k, v] of Object.entries(rows?.[0] ?? {})) {
+    const n = Number(v);
+    if (Number.isFinite(n)) out[k] = n;
+  }
+  return out;
+}
 function useDebounced(value, ms, enabled) {
-  const [v, setV] = React13.useState(value);
-  React13.useEffect(() => {
+  const [v, setV] = React14.useState(value);
+  React14.useEffect(() => {
     if (!enabled) {
       setV(value);
       return;
@@ -2759,23 +3140,23 @@ function useWidgetData(args) {
     searchDebounceMs = 400
   } = args;
   const rt = useZvolvRuntime();
-  const [sourceRows, setSourceRows] = React13.useState([]);
-  const [userLabels, setUserLabels] = React13.useState({});
-  const [initialLoading, setInitialLoading] = React13.useState(true);
-  const [loading, setLoading] = React13.useState(false);
-  const [error, setError] = React13.useState(null);
-  const [nonce, setNonce] = React13.useState(0);
-  const requestedUserIds = React13.useRef(/* @__PURE__ */ new Set());
-  const reqSeq = React13.useRef(0);
-  const config = React13.useMemo(() => parseConfig(configurations), [configurations]);
-  const series = React13.useMemo(() => resolveSeries(config), [config]);
-  const xKey = React13.useMemo(() => resolveXKey(series), [series]);
-  const configured = React13.useMemo(() => isDataSourceConfigured(dataSource), [dataSource]);
+  const [sourceRows, setSourceRows] = React14.useState([]);
+  const [userLabels, setUserLabels] = React14.useState({});
+  const [initialLoading, setInitialLoading] = React14.useState(true);
+  const [loading, setLoading] = React14.useState(false);
+  const [error, setError] = React14.useState(null);
+  const [nonce, setNonce] = React14.useState(0);
+  const requestedUserIds = React14.useRef(/* @__PURE__ */ new Set());
+  const reqSeq = React14.useRef(0);
+  const config = React14.useMemo(() => parseConfig(configurations), [configurations]);
+  const series = React14.useMemo(() => resolveSeries(config), [config]);
+  const xKey = React14.useMemo(() => resolveXKey(series), [series]);
+  const configured = React14.useMemo(() => isDataSourceConfigured(dataSource), [dataSource]);
   const hasAutomation = !!automationRows;
   const tableMode = resolveTableMode(dataSource, widgetType, hasAutomation);
   const filterMode = resolveFilterMode(dataSource, hasAutomation);
   const debouncedSearch = useDebounced(search, searchDebounceMs, tableMode === "remote");
-  const remote = React13.useMemo(() => ({
+  const remote = React14.useMemo(() => ({
     search: tableMode === "remote" ? debouncedSearch : "",
     columnFilters: tableMode === "remote" ? columnFilters : void 0,
     sort: tableMode === "remote" ? sort : null,
@@ -2787,14 +3168,35 @@ function useWidgetData(args) {
   const localKey = JSON.stringify(localFilters ?? {});
   const dsKey = JSON.stringify(dataSource ?? {});
   const remoteKey = JSON.stringify(remote);
-  const normalize = React13.useCallback((incoming) => {
-    const withPostOps = applyPostOperations(incoming, dataSource?.pivot?.postOperations);
+  const dateGapKey = JSON.stringify(dateGap ?? null);
+  const gapTimeZone = React14.useMemo(() => {
+    if (dateGap?.timeZone) return dateGap.timeZone;
+    const row = (dataSource?.pivot?.rows || []).find((r) => r?.title === xKey && r?.interval);
+    return row?.timeZone || void 0;
+  }, [dateGap?.timeZone, dataSource, xKey]);
+  const normalize = React14.useCallback((incoming, fetchedBaseline) => {
+    const percentiles = percentileSummaries(dataSource?.pivot?.summary);
+    const flat = percentiles.length ? flattenPercentiles(incoming, percentiles) : incoming;
+    const withPostOps = applyPostOperations(flat, dataSource?.pivot?.postOperations);
     const numeric = coerceSeriesNumbers(withPostOps, series);
     if (!dateGap) return numeric;
-    const range = dateGap.start && dateGap.end ? { start: dayjs8__default.default(dateGap.start).startOf(dateGap.unit), end: dayjs8__default.default(dateGap.end).startOf(dateGap.unit) } : null;
-    return fillDateGaps({ rows: numeric, xKey, series, unit: dateGap.unit, range });
-  }, [dataSource, series, xKey, dateGap]);
-  React13.useEffect(() => {
+    const tz = gapTimeZone;
+    const period = (v) => startOfPeriod(parseDateValue(v, tz), dateGap.unit, tz);
+    const range = dateGap.start && dateGap.end ? { start: period(dateGap.start), end: period(dateGap.end) } : null;
+    const filled = fillDateGaps({ rows: numeric, xKey, series, unit: dateGap.unit, range, merge: dateGap.merge, timeZone: tz });
+    if (!dateGap.cumulative) return filled;
+    let inRange = filled;
+    if (dateGap.start && !range) {
+      const from = period(dateGap.start).valueOf();
+      inRange = filled.filter((row) => {
+        const d = parseDateValue(row?.[xKey], tz);
+        return !d.isValid() || startOfPeriod(d, dateGap.unit, tz).valueOf() >= from;
+      });
+    }
+    const fields = dateGap.cumulative === true ? series.map((s) => s.valueField) : dateGap.cumulative;
+    return applyCumulative(inRange, xKey, fields, { ...fetchedBaseline || {}, ...dateGap.baseline || {} });
+  }, [dataSource, series, xKey, dateGap, gapTimeZone]);
+  React14.useEffect(() => {
     if (automationRows) {
       if (automationLoading) {
         setLoading(true);
@@ -2815,53 +3217,67 @@ function useWidgetData(args) {
     let cancelled = false;
     setError(null);
     setLoading(true);
+    const queryForm = async (ds, mode, extraClauses = []) => {
+      const formId = ds.formId ?? ds.fields?.[0]?.formID;
+      const withFormId = formId ? { ...ds, formId } : ds;
+      const merged = mergeHostFilters(localFilters, dashFilters);
+      const cfgWithDates = { ...config, cdateFilters: mode === "main" ? cdateFilters : [] };
+      const dashboardFilters = rt.formatDashboardFilters ? [...rt.formatDashboardFilters(cfgWithDates, withFormId, merged) || []] : [];
+      if (remote.widgetFilters?.length) {
+        dashboardFilters.push(...buildWidgetFilterClauses(withFormId, remote.widgetFilters));
+      }
+      if (mode === "main" && remote.columnFilters && Object.keys(remote.columnFilters).length) {
+        dashboardFilters.push(...rt.formatHeaderFilters ? rt.formatHeaderFilters(withFormId, remote.columnFilters) || [] : buildColumnFilterClauses(withFormId, remote.columnFilters));
+      }
+      const searchClause = mode === "main" ? buildSearchClause(remote.search) : null;
+      if (searchClause) dashboardFilters.push(searchClause);
+      dashboardFilters.push(...extraClauses);
+      const { dashboardSort, config: queryConfig } = buildRemoteSort(config, withFormId, mode === "main" ? remote.sort : null);
+      if (formId && !ds.isTask && rt.client?.workflow?.getSingleForm) {
+        const form = await getFormOnce(rt.client, formId).catch((e) => {
+          console.warn(`[@zestl/zvolv-widgets] form lookup failed for ${formId}; querying anyway`, e);
+          return true;
+        });
+        if (!form) throw new Error("You don't have access to this widget's form.");
+      }
+      const fixedDs = mode === "main" && ALIGN_TYPES.has(String(widgetType ?? "").toUpperCase()) && hasDeclaredSeries(config) ? alignSummaryToSeries(withFormId, series) : withFormId;
+      const loggedInUser = rt.resolveQueryUser ? await rt.resolveQueryUser() : null;
+      const mappings = rt.prefetchQueryMappings ? await rt.prefetchQueryMappings(fixedDs.formId) : void 0;
+      if (!rt.generateQuery) throw new Error("runtime.generateQuery is not configured");
+      const query = rt.generateQuery(
+        queryConfig,
+        fixedDs,
+        fixedDs.formId,
+        0,
+        rowLimit,
+        [],
+        dashboardFilters,
+        [],
+        loggedInUser,
+        dashboardSort,
+        null,
+        fixedDs.isTask,
+        mappings
+      );
+      const res = await rt.client.workflow.elasticSearch(query);
+      return Array.isArray(res) ? res : res?.elements ?? res?.data ?? [];
+    };
     (async () => {
       try {
         const ds = dataSource || {};
         let fetched = [];
+        let fetchedBaseline;
         if (usesFormFramework(ds)) {
-          const formId = ds.formId ?? ds.fields?.[0]?.formID;
-          const withFormId = formId ? { ...ds, formId } : ds;
-          const merged = mergeHostFilters(localFilters, dashFilters);
-          const cfgWithDates = { ...config, cdateFilters };
-          const dashboardFilters = rt.formatDashboardFilters ? [...rt.formatDashboardFilters(cfgWithDates, withFormId, merged) || []] : [];
-          if (remote.widgetFilters?.length) {
-            dashboardFilters.push(...buildWidgetFilterClauses(withFormId, remote.widgetFilters));
-          }
-          if (remote.columnFilters && Object.keys(remote.columnFilters).length) {
-            dashboardFilters.push(...rt.formatHeaderFilters ? rt.formatHeaderFilters(withFormId, remote.columnFilters) || [] : buildColumnFilterClauses(withFormId, remote.columnFilters));
-          }
-          const searchClause = buildSearchClause(remote.search);
-          if (searchClause) dashboardFilters.push(searchClause);
-          const { dashboardSort, config: queryConfig } = buildRemoteSort(config, withFormId, remote.sort);
-          if (formId && !ds.isTask && rt.client?.workflow?.getSingleForm) {
-            const form = await getFormOnce(rt.client, formId).catch((e) => {
-              console.warn(`[@zestl/zvolv-widgets] form lookup failed for ${formId}; querying anyway`, e);
-              return true;
-            });
-            if (!form) throw new Error("You don't have access to this widget's form.");
-          }
-          const fixedDs = ALIGN_TYPES.has(String(widgetType ?? "").toUpperCase()) && hasDeclaredSeries(config) ? alignSummaryToSeries(withFormId, series) : withFormId;
-          const loggedInUser = rt.resolveQueryUser ? await rt.resolveQueryUser() : null;
-          const mappings = rt.prefetchQueryMappings ? await rt.prefetchQueryMappings(fixedDs.formId) : void 0;
-          if (!rt.generateQuery) throw new Error("runtime.generateQuery is not configured");
-          const query = rt.generateQuery(
-            queryConfig,
-            fixedDs,
-            fixedDs.formId,
-            0,
-            rowLimit,
-            [],
-            dashboardFilters,
-            [],
-            loggedInUser,
-            dashboardSort,
-            null,
-            fixedDs.isTask,
-            mappings
-          );
-          const res = await rt.client.workflow.elasticSearch(query);
-          fetched = Array.isArray(res) ? res : res?.elements ?? res?.data ?? [];
+          const baselineReq = dateGap?.baselineSource && dateGap.start ? queryForm(
+            dateGap.baselineSource.dataSource,
+            "baseline",
+            [baselineClause(dateGap.baselineSource, startOfPeriod(parseDateValue(dateGap.start, gapTimeZone), dateGap.unit, gapTimeZone))]
+          ).catch((e) => {
+            console.warn("[@zestl/zvolv-widgets] dateGap baseline fetch failed; starting from 0", e);
+            return [];
+          }) : null;
+          fetched = await queryForm(ds, "main");
+          if (baselineReq) fetchedBaseline = readBaseline(await baselineReq);
         } else {
           const wftype = config?.dataConfs?.WorkflowTypeID ?? workflowTypeId;
           const res = await rt.client.workflow.getDataSource(JSON.stringify({ widgetId, wftype }));
@@ -2869,7 +3285,7 @@ function useWidgetData(args) {
           fetched = payload?.table ?? (Array.isArray(payload) ? payload : []);
         }
         if (cancelled || seq !== reqSeq.current) return;
-        setSourceRows(normalize(fetched));
+        setSourceRows(normalize(fetched, fetchedBaseline));
       } catch (err) {
         if (cancelled || seq !== reqSeq.current) return;
         console.error(`[@zestl/zvolv-widgets] ${widgetType ?? "widget"} fetch failed:`, err);
@@ -2885,8 +3301,8 @@ function useWidgetData(args) {
     return () => {
       cancelled = true;
     };
-  }, [configKey, dashKey, cdateKey, localKey, dsKey, remoteKey, configured, nonce, automationRows, automationLoading]);
-  const userKind = React13.useMemo(() => {
+  }, [configKey, dashKey, cdateKey, localKey, dsKey, remoteKey, dateGapKey, configured, nonce, automationRows, automationLoading]);
+  const userKind = React14.useMemo(() => {
     if (!rt.getUserFieldKind) return null;
     const field2 = (dataSource?.fields || []).find(
       (f) => f?.masterfield === xKey || f?.header === xKey
@@ -2896,7 +3312,7 @@ function useWidgetData(args) {
     );
     return rt.getUserFieldKind(field2?.masterFieldType ?? pivotRow?.masterFieldType);
   }, [rt, dataSource, xKey]);
-  React13.useEffect(() => {
+  React14.useEffect(() => {
     if (!userKind || !rt.resolveUserLabels || sourceRows.length === 0) return;
     const pending2 = sourceRows.flatMap((row) => {
       const v = row?.[xKey];
@@ -2922,14 +3338,14 @@ function useWidgetData(args) {
       cancelled = true;
     };
   }, [sourceRows, userKind, xKey, rt]);
-  const toLabel = React13.useCallback((value) => {
+  const toLabel = React14.useCallback((value) => {
     if (!userKind || value === null || value === void 0 || value === "") return value;
     if (Array.isArray(value)) {
       return value.map((v) => userLabels[String(v)] ?? v).filter((v) => v !== "" && v != null).join(", ");
     }
     return userLabels[String(value)] ?? value;
   }, [userKind, userLabels]);
-  const rows = React13.useMemo(() => {
+  const rows = React14.useMemo(() => {
     let out = sourceRows;
     if (filterMode === "local" && widgetFilters?.length) out = applyLocalWidgetFilters(out, widgetFilters);
     if (tableMode === "local") {
@@ -2948,7 +3364,7 @@ function useWidgetData(args) {
     loading,
     initialLoading,
     error,
-    refresh: React13.useCallback(() => setNonce((n) => n + 1), []),
+    refresh: React14.useCallback(() => setNonce((n) => n + 1), []),
     meta: {
       xKey,
       series,
@@ -2962,10 +3378,10 @@ function useWidgetData(args) {
   };
 }
 function useControllable(controlled, initial, onChange) {
-  const [inner, setInner] = React13.useState(initial);
+  const [inner, setInner] = React14.useState(initial);
   const isControlled = controlled !== void 0;
   const value = isControlled ? controlled : inner;
-  const set = React13.useCallback((v) => {
+  const set = React14.useCallback((v) => {
     if (!isControlled) setInner(v);
     onChange?.(v);
   }, [isControlled, onChange]);
@@ -2992,56 +3408,56 @@ function useWidgetInteractions(props = {}) {
     props.defaultWidgetFilters ?? EMPTY_INTERACTIONS.widgetFilters,
     props.onWidgetFiltersChange
   );
-  const latest = React13.useRef({ search, columnFilters, sort, widgetFilters });
+  const latest = React14.useRef({ search, columnFilters, sort, widgetFilters });
   latest.current = { search, columnFilters, sort, widgetFilters };
   const onAny = props.onInteractionsChange;
-  const report = React13.useCallback((patch) => {
+  const report = React14.useCallback((patch) => {
     const next = { ...latest.current, ...patch };
     latest.current = next;
     onAny?.(next);
   }, [onAny]);
-  const setSearch = React13.useCallback((v) => {
+  const setSearch = React14.useCallback((v) => {
     setSearchRaw(v);
     report({ search: v });
   }, [setSearchRaw, report]);
-  const setColumnFilters = React13.useCallback((v) => {
+  const setColumnFilters = React14.useCallback((v) => {
     setColumnFiltersRaw(v);
     report({ columnFilters: v });
   }, [setColumnFiltersRaw, report]);
-  const setColumnFilter = React13.useCallback((key, values) => {
+  const setColumnFilter = React14.useCallback((key, values) => {
     const next = { ...latest.current.columnFilters };
     if (values && values.length) next[key] = values;
     else delete next[key];
     setColumnFilters(next);
   }, [setColumnFilters]);
-  const setSort = React13.useCallback((v) => {
+  const setSort = React14.useCallback((v) => {
     setSortRaw(v);
     report({ sort: v });
   }, [setSortRaw, report]);
-  const toggleSort = React13.useCallback((key) => {
+  const toggleSort = React14.useCallback((key) => {
     const cur = latest.current.sort;
     if (!cur || cur.key !== key) setSort({ key, direction: "asc" });
     else if (cur.direction === "asc") setSort({ key, direction: "desc" });
     else setSort(null);
   }, [setSort]);
-  const setWidgetFilters = React13.useCallback((v) => {
+  const setWidgetFilters = React14.useCallback((v) => {
     setWidgetFiltersRaw(v);
     report({ widgetFilters: v });
   }, [setWidgetFiltersRaw, report]);
-  const addWidgetFilter = React13.useCallback((f) => {
+  const addWidgetFilter = React14.useCallback((f) => {
     setWidgetFilters([...latest.current.widgetFilters, f]);
   }, [setWidgetFilters]);
-  const removeWidgetFilter = React13.useCallback((index) => {
+  const removeWidgetFilter = React14.useCallback((index) => {
     setWidgetFilters(latest.current.widgetFilters.filter((_2, i) => i !== index));
   }, [setWidgetFilters]);
-  const clearAll = React13.useCallback(() => {
+  const clearAll = React14.useCallback(() => {
     setSearchRaw("");
     setColumnFiltersRaw({});
     setSortRaw(null);
     setWidgetFiltersRaw([]);
     report({ ...EMPTY_INTERACTIONS });
   }, [setSearchRaw, setColumnFiltersRaw, setSortRaw, setWidgetFiltersRaw, report]);
-  return React13.useMemo(() => ({
+  return React14.useMemo(() => ({
     search,
     columnFilters,
     sort,
@@ -3154,7 +3570,7 @@ function describeWidgetFilter(f) {
 function useInteractiveWidgetData(props, options = {}) {
   const t = useTokens();
   const interactions = useWidgetInteractions(props);
-  const dataArgs = React13.useMemo(() => {
+  const dataArgs = React14.useMemo(() => {
     const rest = { ...props };
     for (const k of UI_KEYS) delete rest[k];
     return rest;
@@ -3166,7 +3582,7 @@ function useInteractiveWidgetData(props, options = {}) {
     sort: interactions.sort,
     widgetFilters: interactions.widgetFilters
   });
-  const config = React13.useMemo(
+  const config = React14.useMemo(
     () => resolveWidgetDefaults(t, props.widgetType, parseConfig(props.configurations)),
     [t, props.widgetType, props.configurations]
   );
@@ -3176,7 +3592,7 @@ function useInteractiveWidgetData(props, options = {}) {
     showColumnFilter: !!options.table && (props.showColumnFilter ?? !!(config?.showColumnFilter ?? config?.styling?.showColumnFilter ?? props.renderColumnFilter)),
     enableSort: !!options.table && (props.enableSort ?? config?.enableSort !== false)
   };
-  const seen = React13.useRef({ ds: "", values: /* @__PURE__ */ new Map() });
+  const seen = React14.useRef({ ds: "", values: /* @__PURE__ */ new Map() });
   const dsKey = JSON.stringify(props.dataSource ?? {});
   if (seen.current.ds !== dsKey) seen.current = { ds: dsKey, values: /* @__PURE__ */ new Map() };
   const getColumnOptions = (key) => {
@@ -3194,7 +3610,7 @@ function useInteractiveWidgetData(props, options = {}) {
     }
     return [...byValue.values()];
   };
-  const fields = React13.useMemo(() => filterableFields(props.dataSource), [dsKey]);
+  const fields = React14.useMemo(() => filterableFields(props.dataSource), [dsKey]);
   const searchNode = flags.showSearch ? (() => {
     const args = {
       value: interactions.search,
@@ -3237,7 +3653,7 @@ function useInteractiveWidgetData(props, options = {}) {
         tokens: t
       };
       parts.push(
-        /* @__PURE__ */ jsxRuntime.jsx(React13__default.default.Fragment, { children: props.renderSortIndicator ? props.renderSortIndicator(args) : /* @__PURE__ */ jsxRuntime.jsx(DefaultSortIndicator, { ...args }) }, "sort")
+        /* @__PURE__ */ jsxRuntime.jsx(React14__default.default.Fragment, { children: props.renderSortIndicator ? props.renderSortIndicator(args) : /* @__PURE__ */ jsxRuntime.jsx(DefaultSortIndicator, { ...args }) }, "sort")
       );
     }
     if (flags.showColumnFilter) {
@@ -3251,7 +3667,7 @@ function useInteractiveWidgetData(props, options = {}) {
         tokens: t
       };
       parts.push(
-        /* @__PURE__ */ jsxRuntime.jsx(React13__default.default.Fragment, { children: props.renderColumnFilter ? props.renderColumnFilter(args) : /* @__PURE__ */ jsxRuntime.jsx(DefaultColumnFilter, { ...args }) }, "filter")
+        /* @__PURE__ */ jsxRuntime.jsx(React14__default.default.Fragment, { children: props.renderColumnFilter ? props.renderColumnFilter(args) : /* @__PURE__ */ jsxRuntime.jsx(DefaultColumnFilter, { ...args }) }, "filter")
       );
     }
     return parts.length ? /* @__PURE__ */ jsxRuntime.jsx(jsxRuntime.Fragment, { children: parts }) : null;
@@ -3293,9 +3709,9 @@ var DefaultSearch = ({ value, setValue, placeholder, tokens: t }) => /* @__PURE_
   }
 );
 var Popover = ({ trigger, children, tokens: t, align = "right" }) => {
-  const [open, setOpen] = React13.useState(false);
-  const ref = React13.useRef(null);
-  React13.useEffect(() => {
+  const [open, setOpen] = React14.useState(false);
+  const ref = React14.useRef(null);
+  React14.useEffect(() => {
     if (!open) return;
     const onDown = (e) => {
       if (ref.current && !ref.current.contains(e.target)) setOpen(false);
@@ -3357,7 +3773,7 @@ var DefaultSortIndicator = ({ direction, toggle, column, tokens: t }) => /* @__P
   }
 );
 var DefaultColumnFilter = ({ column, selected, setSelected, clear, options, tokens: t }) => {
-  const [q, setQ] = React13.useState("");
+  const [q, setQ] = React14.useState("");
   const shown = options.filter((o) => !q || o.label.toLowerCase().includes(q.toLowerCase()));
   const isOn = (v) => selected.some((s) => String(s) === String(v));
   return /* @__PURE__ */ jsxRuntime.jsx(Popover, { tokens: t, align: "left", trigger: (_2, toggle) => /* @__PURE__ */ jsxRuntime.jsx(
@@ -3385,10 +3801,10 @@ var DefaultColumnFilter = ({ column, selected, setSelected, clear, options, toke
 };
 var DATE_TOKENS = ["TODAY", "YESTERDAY", "LAST_SEVEN_DAYS", "LAST_THIRTY_DAYS", "THIS_WEEK", "THIS_MONTH", "THIS_YEAR"];
 var DefaultWidgetFilter = ({ filters: filters2, addFilter, removeFilter, clear, fields, tokens: t }) => {
-  const [field2, setField] = React13.useState("");
-  const [operator, setOperator] = React13.useState("");
-  const [value, setValue] = React13.useState("");
-  const [value2, setValue2] = React13.useState("");
+  const [field2, setField] = React14.useState("");
+  const [operator, setOperator] = React14.useState("");
+  const [value, setValue] = React14.useState("");
+  const [value2, setValue2] = React14.useState("");
   const current = fields.find((f) => f.field === field2) ?? fields[0];
   const op = operator && current?.operators.includes(operator) ? operator : current?.operators[0] ?? "IN";
   const valueless = op === "EMPTY" || op === "NOT_EMPTY";
@@ -3624,7 +4040,7 @@ function useKpiContents({
   defaultIconColor = "#7b8499",
   dateFormatter
 }) {
-  return React13.useMemo(() => {
+  return React14.useMemo(() => {
     if (!contents?.length) return [];
     const row = rows?.[0];
     return contents.map((content, i) => {
@@ -3739,31 +4155,100 @@ function resolveDrillDown(config = {}) {
 }
 var WIDGET_TYPE = "KPI_CARD";
 var KpiWidget = (props) => {
-  const { title, description, emptyMessage, unconfiguredMessage, className, style, onItemClick, ...dataArgs } = props;
+  const {
+    title,
+    description,
+    emptyMessage,
+    unconfiguredMessage,
+    className,
+    style,
+    onItemClick,
+    externalSeriesByIndex,
+    ...dataArgs
+  } = props;
   const ix = useInteractiveWidgetData({ ...dataArgs, widgetType: WIDGET_TYPE });
   const { data, config, tokens: t } = ix;
   const chrome = resolveChromeConfig(config);
   const contents = config?.cardConfig?.contents ?? config?.contents ?? [];
   const cardTemplate = config?.cardConfig?.template ?? config?.template ?? "standard";
-  const vms = useKpiContents({ contents, rows: data.rows, cardTemplate });
+  const [fetchedSeries, setFetchedSeries] = React14.useState({});
+  const onSeries = React14.useCallback((index, values) => {
+    setFetchedSeries((prev) => {
+      if (JSON.stringify(prev[index]) === JSON.stringify(values)) return prev;
+      const next = { ...prev };
+      if (values) next[index] = values;
+      else delete next[index];
+      return next;
+    });
+  }, []);
+  const seriesByIndex = React14.useMemo(
+    () => externalSeriesByIndex ? { ...fetchedSeries, ...externalSeriesByIndex } : fetchedSeries,
+    [fetchedSeries, externalSeriesByIndex]
+  );
+  const vms = useKpiContents({ contents, rows: data.rows, cardTemplate, externalSeriesByIndex: seriesByIndex });
   const state = data.state === "empty" && contents.length > 0 ? "ready" : data.state;
-  return /* @__PURE__ */ jsxRuntime.jsx(
-    WidgetShell,
-    {
-      widgetType: WIDGET_TYPE,
-      title: chrome.showHeader ? title ?? chrome.title : void 0,
-      description: description ?? chrome.description,
-      state,
-      error: data.error,
-      emptyMessage: emptyMessage ?? chrome.emptyMessage,
-      unconfiguredMessage,
-      className,
-      style,
-      actions: ix.toolbar,
-      ...ix.shell,
-      children: /* @__PURE__ */ jsxRuntime.jsx("div", { style: { display: "flex", flexDirection: "column", gap: 14, height: "100%" }, children: vms.map((vm, i) => /* @__PURE__ */ jsxRuntime.jsx(KpiItem, { vm, index: i, onClick: onItemClick }, i)) })
-    }
+  return /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+    contents.map(
+      (content, i) => content?.seriesSource?.mode === "timeseries" && content.seriesSource.dataSource && !externalSeriesByIndex?.[i] ? /* @__PURE__ */ jsxRuntime.jsx(
+        KpiSeriesFetcher,
+        {
+          index: i,
+          source: content.seriesSource,
+          onSeries,
+          dashFilters: dataArgs.dashFilters,
+          cdateFilters: dataArgs.cdateFilters,
+          localFilters: dataArgs.localFilters,
+          workflowTypeId: dataArgs.workflowTypeId
+        },
+        i
+      ) : null
+    ),
+    /* @__PURE__ */ jsxRuntime.jsx(
+      WidgetShell,
+      {
+        widgetType: WIDGET_TYPE,
+        title: chrome.showHeader ? title ?? chrome.title : void 0,
+        description: description ?? chrome.description,
+        state,
+        error: data.error,
+        emptyMessage: emptyMessage ?? chrome.emptyMessage,
+        unconfiguredMessage,
+        className,
+        style,
+        actions: ix.toolbar,
+        ...ix.shell,
+        children: /* @__PURE__ */ jsxRuntime.jsx("div", { style: { display: "flex", flexDirection: "column", gap: 14, height: "100%" }, children: vms.map((vm, i) => /* @__PURE__ */ jsxRuntime.jsx(KpiItem, { vm, index: i, onClick: onItemClick }, i)) })
+      }
+    )
+  ] });
+};
+var KpiSeriesFetcher = ({ index, source, onSeries, dashFilters, cdateFilters, localFilters, workflowTypeId }) => {
+  const { dataSource, xField, valueField, dateGap } = source;
+  const configurations = React14.useMemo(
+    () => ({ series: [{ argumentField: xField, valueField }] }),
+    [xField, valueField]
+  );
+  const data = useWidgetData({
+    widgetType: "KPI_SERIES",
+    dataSource,
+    configurations,
+    dateGap: dateGap ?? null,
+    dashFilters,
+    cdateFilters,
+    localFilters,
+    workflowTypeId
+  });
+  const values = React14.useMemo(
+    () => data.rows.map((r) => toNum(r?.[valueField])).filter((n) => n != null),
+    [data.rows, valueField]
   );
+  const ready = data.state === "ready" || data.state === "empty";
+  const key = ready ? JSON.stringify(values) : "";
+  React14.useEffect(() => {
+    onSeries(index, ready ? values : void 0);
+  }, [index, key, ready, onSeries]);
+  React14.useEffect(() => () => onSeries(index, void 0), [index, onSeries]);
+  return null;
 };
 var KpiItem = ({
   vm,
@@ -3796,7 +4281,7 @@ var ChartWidget = (props) => {
   } = props;
   const ix = useInteractiveWidgetData({ ...dataArgs, widgetType });
   const { data, config, tokens: t } = ix;
-  const colorFor = React13.useMemo(() => {
+  const colorFor = React14.useMemo(() => {
     const palette = t.colors.charts.palette;
     return (index, s) => {
       if (s?.color) return s.color;
@@ -3820,7 +4305,7 @@ var ChartWidget = (props) => {
   const renderer = render ?? children;
   let body;
   if (renderer) body = renderer(args);
-  else if (override) body = React13__default.default.createElement(override, args);
+  else if (override) body = React14__default.default.createElement(override, args);
   else body = /* @__PURE__ */ jsxRuntime.jsx(FallbackBars, { ...args });
   return /* @__PURE__ */ jsxRuntime.jsx(
     WidgetShell,
@@ -3884,7 +4369,7 @@ var RankingBarWidget = (props) => {
   const valueField = ranking.valueField ?? data.meta.series[0]?.valueField ?? "value";
   const order = ranking.order === "asc" ? "asc" : "desc";
   const limit = toNum(ranking.limit) ?? 10;
-  const { rows, max } = React13.useMemo(() => {
+  const { rows, max } = React14.useMemo(() => {
     const mapped = data.rows.map((r) => ({
       label: r[labelField],
       value: toNum(r[valueField]) ?? 0,
@@ -3930,7 +4415,7 @@ var RankingBarWidget = (props) => {
       style,
       actions: ix.toolbar,
       ...ix.shell,
-      children: render ? render(args) : override ? React13__default.default.createElement(override, args) : /* @__PURE__ */ jsxRuntime.jsx(DefaultRanking, { ...args })
+      children: render ? render(args) : override ? React14__default.default.createElement(override, args) : /* @__PURE__ */ jsxRuntime.jsx(DefaultRanking, { ...args })
     }
   );
 };
@@ -4038,7 +4523,7 @@ var HeatMapWidget = (props) => {
     medium: toNum(hm.thresholds?.medium?.value) ?? 60,
     high: toNum(hm.thresholds?.high?.value) ?? 100
   };
-  const cells = React13.useMemo(() => data.rows.map((row) => {
+  const cells = React14.useMemo(() => data.rows.map((row) => {
     const count = toNum(row[countField]) ?? 0;
     const band = count <= thresholds.low ? "low" : count <= thresholds.medium ? "medium" : "high";
     const configured = hm.thresholds?.[band]?.color;
@@ -4153,7 +4638,7 @@ function resolveCollectionMapping(config, series) {
   return { ...fromSeries, ...block ?? config ?? {} };
 }
 function useCollectionItems(rows, mapping) {
-  return React13.useMemo(() => {
+  return React14.useMemo(() => {
     const m = mapping ?? {};
     const detailFields = m.fields ?? m.dataConfs ?? [];
     return rows.map((row, i) => {
@@ -4192,7 +4677,7 @@ var CollectionWidget = (props) => {
   const ix = useInteractiveWidgetData({ ...dataArgs, widgetType });
   const { data, config, tokens: t } = ix;
   const chrome = resolveChromeConfig(config);
-  const mapping = React13.useMemo(() => resolveCollectionMapping(config, data.meta.series), [config, data.meta.series]);
+  const mapping = React14.useMemo(() => resolveCollectionMapping(config, data.meta.series), [config, data.meta.series]);
   const items = useCollectionItems(data.rows, mapping);
   const template = config?.template || "standard";
   const override = useTemplateOverride(widgetType, template);
@@ -4218,7 +4703,7 @@ var CollectionWidget = (props) => {
       style,
       actions: ix.toolbar,
       ...ix.shell,
-      children: render ? render(args) : override ? React13__default.default.createElement(override, args) : /* @__PURE__ */ jsxRuntime.jsx(DefaultList, { ...args })
+      children: render ? render(args) : override ? React14__default.default.createElement(override, args) : /* @__PURE__ */ jsxRuntime.jsx(DefaultList, { ...args })
     }
   );
 };
@@ -4287,7 +4772,7 @@ var KIND_BY_TYPE = {
   RICHTEXT: "html"
 };
 function useTableColumns(explicit, config, rows) {
-  return React13.useMemo(() => {
+  return React14.useMemo(() => {
     if (explicit?.length) return explicit;
     const declared = [config?.columns, config?.additionalProperties?.columns, config?.fields, config?.table?.columns].find((d) => Array.isArray(d) && d.length);
     if (Array.isArray(declared) && declared.length) {
@@ -4388,8 +4873,8 @@ var DefaultCell = ({ value, column, tokens: t, toLabel }) => {
   if (column.kind === "number") {
     return /* @__PURE__ */ jsxRuntime.jsx("span", { style: { fontFamily: t.monoFontFamily }, children: String(value) });
   }
-  const text = (Array.isArray(value) ? value : [value]).map(displayText).filter(Boolean).join(", ");
-  return /* @__PURE__ */ jsxRuntime.jsx(jsxRuntime.Fragment, { children: String(toLabel(text) ?? text).replace(/<[^>]*>/g, "") });
+  const text2 = (Array.isArray(value) ? value : [value]).map(displayText).filter(Boolean).join(", ");
+  return /* @__PURE__ */ jsxRuntime.jsx(jsxRuntime.Fragment, { children: String(toLabel(text2) ?? text2).replace(/<[^>]*>/g, "") });
 };
 var DefaultTable = ({
   rows,
@@ -4468,11 +4953,11 @@ var PivotGridWidget = (props) => {
 };
 function toDate(v) {
   if (v === null || v === void 0 || v === "") return null;
-  const d = dayjs8__default.default(v);
+  const d = dayjs4__default.default(v);
   return d.isValid() ? d.toDate() : null;
 }
 function useTemporalEvents(rows, mapping) {
-  return React13.useMemo(() => {
+  return React14.useMemo(() => {
     const m = mapping ?? {};
     const titleField = m.taskTitle ?? m.titleField ?? m.title ?? m.labelField;
     const groupField = m.projectTitle ?? m.groupField ?? m.group ?? m.resourceField;
@@ -4493,7 +4978,7 @@ function useTemporalEvents(rows, mapping) {
         start,
         end,
         // With no time component on either bound, treat it as an all-day span.
-        allDay: !!(start && !end) || !!start && dayjs8__default.default(start).startOf("day").isSame(start),
+        allDay: !!(start && !end) || !!start && dayjs4__default.default(start).startOf("day").isSame(start),
         status: statusRaw !== void 0 ? { label: statusRaw, tone: statusTone(statusRaw) } : void 0,
         progress: Number.isFinite(rawProgress) ? Math.max(0, Math.min(1, rawProgress > 1 ? rawProgress / 100 : rawProgress)) : void 0,
         color: colorField ? row?.[colorField] : void 0,
@@ -4520,12 +5005,12 @@ var TemporalWidget = (props) => {
   const chrome = resolveChromeConfig(config);
   const mapping = config?.timeline ?? config?.gantt ?? config?.calendar ?? config?.scheduler ?? config?.mapping ?? config;
   const events = useTemporalEvents(data.rows, mapping);
-  const range = React13.useMemo(() => {
+  const range = React14.useMemo(() => {
     const stamps = events.flatMap((e) => [e.start, e.end].filter(Boolean).map((d) => d.getTime()));
     if (!stamps.length) return null;
     return { start: new Date(Math.min(...stamps)), end: new Date(Math.max(...stamps)) };
   }, [events]);
-  const lanes = React13.useMemo(() => {
+  const lanes = React14.useMemo(() => {
     const map = /* @__PURE__ */ new Map();
     events.forEach((e) => {
       const key = String(e.group ?? "");
@@ -4560,7 +5045,7 @@ var TemporalWidget = (props) => {
       style,
       actions: ix.toolbar,
       ...ix.shell,
-      children: render ? render(args) : override ? React13__default.default.createElement(override, args) : /* @__PURE__ */ jsxRuntime.jsx(DefaultTimeline, { ...args })
+      children: render ? render(args) : override ? React14__default.default.createElement(override, args) : /* @__PURE__ */ jsxRuntime.jsx(DefaultTimeline, { ...args })
     }
   );
 };
@@ -4587,8 +5072,8 @@ var DefaultTimeline = ({ events, tokens: t, onEventClick }) => /* @__PURE__ */ j
       /* @__PURE__ */ jsxRuntime.jsxs("div", { style: { minWidth: 0, flex: 1 }, children: [
         /* @__PURE__ */ jsxRuntime.jsx("div", { style: { fontSize: t.typography.body.fontSize, color: t.colors.textPrimary, fontWeight: 600 }, children: String(e.title ?? "") }),
         /* @__PURE__ */ jsxRuntime.jsxs("div", { style: { fontSize: t.typography.caption.fontSize, color: t.colors.textTertiary }, children: [
-          e.start ? dayjs8__default.default(e.start).format("DD MMM YYYY") : "",
-          e.end ? ` \u2192 ${dayjs8__default.default(e.end).format("DD MMM YYYY")}` : "",
+          e.start ? dayjs4__default.default(e.start).format("DD MMM YYYY") : "",
+          e.end ? ` \u2192 ${dayjs4__default.default(e.end).format("DD MMM YYYY")}` : "",
           e.group ? ` \xB7 ${String(e.group)}` : ""
         ] })
       ] }),
@@ -4619,7 +5104,7 @@ var StepperWidget = (props) => {
   const descField = stepper.descriptionField;
   const statusField = stepper.statusField ?? "status";
   const authored = Array.isArray(stepper.steps) && stepper.steps.length > 0;
-  const steps = React13.useMemo(() => {
+  const steps = React14.useMemo(() => {
     if (authored) {
       const live = stepper.statusField ? String(data.rows[0]?.[stepper.statusField] ?? "").trim().toLowerCase() : "";
       const liveIdx = live ? stepper.steps.findIndex((s) => String(s?.title ?? s?.label ?? "").trim().toLowerCase() === live) : -1;
@@ -4683,7 +5168,7 @@ var StepperWidget = (props) => {
       style,
       actions: ix.toolbar,
       ...ix.shell,
-      children: render ? render(args) : override ? React13__default.default.createElement(override, args) : /* @__PURE__ */ jsxRuntime.jsx(DefaultStepper, { ...args })
+      children: render ? render(args) : override ? React14__default.default.createElement(override, args) : /* @__PURE__ */ jsxRuntime.jsx(DefaultStepper, { ...args })
     }
   );
 };
@@ -4755,19 +5240,19 @@ function renderHtmlVariables(template, rows, variables) {
     } else if (v.dataFormat === "AMOUNT" && typeof value === "number") {
       value = formatAmountValue(value, v.amountSuffix || "Rupees", v.precision ?? 2);
     } else if (v.dataFormat === "DATE" && value) {
-      const d = dayjs8__default.default(value);
+      const d = dayjs4__default.default(value);
       if (d.isValid()) value = d.format(DATE_FORMAT_MAP[v.dateFormat] || "DD/MM/YYYY");
     }
-    let text;
+    let text2;
     if (Array.isArray(value)) {
-      text = value.map((x) => x && typeof x === "object" ? x.view ?? x.title ?? x.name ?? "" : x).filter((x) => x !== "" && x != null).join(", ");
+      text2 = value.map((x) => x && typeof x === "object" ? x.view ?? x.title ?? x.name ?? "" : x).filter((x) => x !== "" && x != null).join(", ");
     } else if (value && typeof value === "object") {
-      text = String(value.view ?? value.title ?? value.name ?? "");
+      text2 = String(value.view ?? value.title ?? value.name ?? "");
     } else {
       const n = typeof value === "number" ? value : Number(value);
-      text = (typeof value === "number" || typeof value === "string" && value.trim() !== "") && !isNaN(n) && !Number.isInteger(n) ? n.toFixed(v.precision ?? 2) : String(value ?? "");
+      text2 = (typeof value === "number" || typeof value === "string" && value.trim() !== "") && !isNaN(n) && !Number.isInteger(n) ? n.toFixed(v.precision ?? 2) : String(value ?? "");
     }
-    out = out.replace(new RegExp(`{{${escapeRe(String(v.label))}}}`, "gi"), text);
+    out = out.replace(new RegExp(`{{${escapeRe(String(v.label))}}}`, "gi"), text2);
   }
   return out;
 }
@@ -4788,7 +5273,7 @@ var HtmlWidget = (props) => {
   const chrome = resolveChromeConfig(config);
   const template = config?.media?.htmlText ?? config?.html ?? config?.content ?? config?.rawHtml ?? "";
   const variables = Array.isArray(config?.variables) ? config.variables : [];
-  const html = React13.useMemo(
+  const html = React14.useMemo(
     () => variables.length ? renderHtmlVariables(template, data.rows, variables) : interpolate(template, data.rows[0]),
     [template, data.rows, variables]
   );
@@ -4825,7 +5310,7 @@ var IframeWidget = (props) => {
   const { data, config, tokens: t } = ix;
   const chrome = resolveChromeConfig(config);
   const raw2 = config?.media?.src ?? config?.url ?? config?.src ?? config?.iframe?.url ?? "";
-  const url = React13.useMemo(() => interpolate(raw2, data.rows[0]), [raw2, data.rows]);
+  const url = React14.useMemo(() => interpolate(raw2, data.rows[0]), [raw2, data.rows]);
   const state = url ? "ready" : data.state === "loading" ? "loading" : "unconfigured";
   return /* @__PURE__ */ jsxRuntime.jsx(
     WidgetShell,
@@ -4865,14 +5350,14 @@ var GoogleMapWidget = (props) => {
   const labelField = m.labelField ?? m.titleField ?? m.pinDataTitle;
   const centerLat = gm?.center?.latitude ?? m.centerLat;
   const centerLng = gm?.center?.longitude ?? m.centerLng;
-  const markers = React13.useMemo(() => data.rows.flatMap((row, i) => {
+  const markers = React14.useMemo(() => data.rows.flatMap((row, i) => {
     const lat = Number(row?.[latField]);
     const lng = Number(row?.[lngField]);
     if (!Number.isFinite(lat) || !Number.isFinite(lng)) return [];
     const label = titleParts.length ? titleParts.map((p, k) => `${k ? p.separator ?? " " : ""}${row?.[p.field] ?? ""}`).join("").trim() : labelField ? row?.[labelField] : void 0;
     return [{ id: row?.id ?? i, lat, lng, label, raw: row }];
   }), [data.rows, latField, lngField, labelField, titleParts]);
-  const center = React13.useMemo(() => {
+  const center = React14.useMemo(() => {
     if (centerLat != null && centerLng != null && Number.isFinite(Number(centerLat))) {
       return { lat: Number(centerLat), lng: Number(centerLng) };
     }
@@ -4919,7 +5404,7 @@ var ActionCardWidget = (props) => {
   const ix = useInteractiveWidgetData({ ...dataArgs, widgetType: "ACTION_CARD" });
   const { data, config, tokens: t } = ix;
   const chrome = resolveChromeConfig(config);
-  const actions = React13.useMemo(() => {
+  const actions = React14.useMemo(() => {
     const declared = config?.actions ?? config?.buttons ?? (config?.action ? [{ ...config.action, actionType: config.actionType, label: config.action.label ?? config.action.FormTitle }] : []);
     return declared.map((a, i) => ({
       id: a?.id ?? a?.FormID ?? i,
@@ -5000,7 +5485,7 @@ var TreeWidget = (props) => {
   const { data, config, tokens: t } = ix;
   const chrome = resolveChromeConfig(config);
   const tree = config?.treeConfiguration ?? config?.tree ?? config ?? {};
-  const nodes = React13.useMemo(() => buildTree(
+  const nodes = React14.useMemo(() => buildTree(
     data.rows,
     tree.idField ?? "id",
     tree.parentField ?? "parentId",
@@ -5240,6 +5725,7 @@ function resolveFieldType(el2) {
   if (sub === "INPUT_IP" || sub === "INPUT_DEVICE_INFO") return sub;
   if (t === "GROUP_VIEW" && ["COLLAPSE_SECTION", "CONTAINER", "STEPPER", "TAB", "MATRIX", "COMMENTS"].includes(sub)) return sub;
   if (["SIGNATURE", "INPUT_RATE", "COMMENTS"].includes(sub)) return sub;
+  if (sub && sub !== t && sub in KIND) return sub;
   if (t === "SCAN") return "INPUT_SCAN";
   if (t === "TRIGGER_AUTOMATION") return "ACTION_BUTTON";
   if (t === "ACTION_DROPDOWN") return "CASCADED_ACTIONS";
@@ -5302,7 +5788,11 @@ var KIND = {
   COMMENTS: "comments",
   ACTION_BUTTON: "action",
   INPUT_TRIGGER: "action",
-  CASCADED_ACTIONS: "action"
+  CASCADED_ACTIONS: "action",
+  // ABA trial widgets (ZAI TimeSamplingField / PercentCorrectField / TaskAnalysisField, zvolv-web z-input-*).
+  INPUT_TIME_SAMPLING: "trials",
+  INPUT_PERCENT_CORRECT: "trials",
+  INPUT_TASK_ANALYSIS: "trials"
 };
 function fieldKindOf(el2) {
   const t = resolveFieldType(el2);
@@ -5551,6 +6041,9 @@ function formulaScalar(v) {
   if (typeof v === "number" || typeof v === "boolean") return v;
   return String(v);
 }
+function toBraceFormula(formula, labels) {
+  return braceLegacyLabels(formula, labels);
+}
 function braceLegacyLabels(formula, labels) {
   if (formula.includes("{")) return formula;
   const sorted = [...labels].filter(Boolean).sort((a, b) => b.length - a.length);
@@ -5586,6 +6079,31 @@ function formulaLabels(formula, labels = []) {
   const src = braceLegacyLabels(String(formula ?? ""), labels);
   return [...new Set([...src.matchAll(/\{([^}]+)\}/g)].map((m) => m[1].trim()))];
 }
+function isServerSafeFormula(formula, labels = []) {
+  const f = String(formula ?? "");
+  if (!f.trim()) return true;
+  return braceLegacyLabels(f, labels) === f;
+}
+function computeRowFormulas(elements, row) {
+  const formulaOf = (e) => (e.type === "INPUT_FORMULA" || e.attributes?.subType === "INPUT_FORMULA") && e.properties?.formula ? String(e.properties.formula) : "";
+  const cols = elements.filter((e) => formulaOf(e));
+  if (!cols.length) return row;
+  const labels = elements.map((e) => e.label).filter(Boolean);
+  const idOf2 = new Map(elements.map((e) => [e.label, e.elementId]));
+  const out = { ...row };
+  for (let pass = 0; pass < 2; pass++) {
+    cols.forEach((c) => {
+      const refs = formulaLabels(formulaOf(c), labels);
+      const empty = (v) => v === null || v === void 0 || v === "";
+      if (refs.length && refs.every((l) => empty(out[idOf2.get(l) ?? l]))) {
+        out[c.elementId] = null;
+        return;
+      }
+      out[c.elementId] = evaluateFormula(formulaOf(c), (l) => out[idOf2.get(l) ?? l], labels);
+    });
+  }
+  return out;
+}
 
 // src/forms/validate.ts
 var URL_RE = /^(?:(?:https?|ftp):\/\/)?(?:[a-z0-9-]+\.)+[a-z]{2,}(?::\d{2,5})?(?:[/?#]\S*)?$/i;
@@ -5635,6 +6153,11 @@ function validateField(el2, value, required = el2.required) {
   const blank = isEmptyValue(value) || t === "RICH_TEXT_EDITOR" && typeof value === "string" && isBlankHtml(value);
   if (required && blank) return `${name} is required`;
   if (blank) return void 0;
+  if ((t === "INPUT_PERCENT_CORRECT" || t === "INPUT_TIME_SAMPLING") && value && typeof value === "object") {
+    const min = Number(el2.properties?.minimumNumberOfTrials ?? 0);
+    const n = Array.isArray(value.buttonResp) ? value.buttonResp.length : 0;
+    if (min > 0 && n < min) return `Trials are less than ${min}`;
+  }
   if (t === "INPUT_EMAIL" && !EMAIL_RE.test(String(value))) return "Enter a valid email address";
   if (t === "INPUT_URL" && !URL_RE.test(String(value))) return "Enter a valid URL";
   if (t === "INPUT_PHONE" && !isValidPhone(String(value), el2.properties?.countryCode)) return "Enter a valid phone number";
@@ -5745,6 +6268,9 @@ function getEmptyValue(type) {
     case "SIGNATURE":
     case "TABLE_START":
     case "MATRIX":
+    case "INPUT_TIME_SAMPLING":
+    case "INPUT_PERCENT_CORRECT":
+    case "INPUT_TASK_ANALYSIS":
       return null;
     default:
       return "";
@@ -5786,7 +6312,7 @@ var DATE_UNITS = {
 };
 function currentUserId(user) {
   const id = user?.userId ?? user?.UserID ?? user?.id;
-  return id != null && id !== "" ? String(id) : void 0;
+  return id != null && id !== "" && !String(id).startsWith("enc::") ? String(id) : void 0;
 }
 function dynamicDefault(el2, user) {
   const dd = el2.attributes?.dynamicDefault ?? el2.attributes?.DynamicDefault ?? el2.properties?.dynamicDefault;
@@ -5794,7 +6320,7 @@ function dynamicDefault(el2, user) {
   const t = resolveFieldType(el2);
   if ((dd.operator === "ADD" || dd.operator === "SUB") && (t === "DATE_PICKER" || t === "DATE_TIME_PICKER")) {
     const sign = dd.operator === "SUB" ? -1 : 1;
-    let d = dayjs8__default.default();
+    let d = dayjs4__default.default();
     const u = dd.units;
     if (typeof u === "number" || typeof u === "string" && u.trim() !== "" && !isNaN(Number(u))) d = d.add(sign * Number(u), "day");
     else Object.entries(u ?? {}).forEach(([k, n]) => {
@@ -5834,7 +6360,7 @@ function buildInitialValues(elements, opts = {}) {
 }
 function formatDateish(t, value) {
   const isDayjs = (v) => v && typeof v === "object" && typeof v.isValid === "function" && typeof v.format === "function";
-  const toD = (v) => isDayjs(v) ? v : v instanceof Date ? dayjs8__default.default(v) : typeof v === "string" && v ? dayjs8__default.default(v) : null;
+  const toD = (v) => isDayjs(v) ? v : v instanceof Date ? dayjs4__default.default(v) : typeof v === "string" && v ? dayjs4__default.default(v) : null;
   if (t === "DATE_PICKER") {
     const d = toD(value);
     return d?.isValid() ? d.format("YYYY-MM-DD") : value;
@@ -5949,9 +6475,9 @@ function formatFieldValue(el2, value) {
   const t = resolveFieldType(el2);
   if (t === "CHECK_BOX") return value ? "Yes" : "No";
   if (RELATIONAL_TYPES.has(t)) return (Array.isArray(value) ? value : [value]).map((v) => v?.view ?? v?.select ?? String(v)).join(", ");
-  if (t === "INPUT_DATE_RANGE" && Array.isArray(value)) return value.filter(Boolean).map((v) => dayjs8__default.default(v).format("D MMM YYYY")).join(" \u2013 ");
-  if (t === "DATE_PICKER") return dayjs8__default.default(value).isValid() ? dayjs8__default.default(value).format("D MMM YYYY") : String(value);
-  if (t === "DATE_TIME_PICKER") return dayjs8__default.default(value).isValid() ? dayjs8__default.default(value).format("D MMM YYYY, HH:mm") : String(value);
+  if (t === "INPUT_DATE_RANGE" && Array.isArray(value)) return value.filter(Boolean).map((v) => dayjs4__default.default(v).format("D MMM YYYY")).join(" \u2013 ");
+  if (t === "DATE_PICKER") return dayjs4__default.default(value).isValid() ? dayjs4__default.default(value).format("D MMM YYYY") : String(value);
+  if (t === "DATE_TIME_PICKER") return dayjs4__default.default(value).isValid() ? dayjs4__default.default(value).format("D MMM YYYY, HH:mm") : String(value);
   if (t === "INPUT_PERCENT") return `${value}%`;
   if (Array.isArray(value)) return value.map((v) => v?.media_name ?? v?.view ?? String(v)).join(", ");
   return String(value);
@@ -6173,6 +6699,67 @@ async function invokeTrigger(client, triggerId, body) {
   }
   return res?.data ?? res;
 }
+async function invokeZeno(client, automationUuid, body) {
+  const res = await wfOf(client).invokeNuclioAutomation(String(automationUuid), body);
+  const payload = res?.data?.raw ?? res?.raw ?? res?.data ?? res;
+  if (typeof payload === "string") {
+    try {
+      return JSON.parse(payload);
+    } catch {
+      return payload;
+    }
+  }
+  return payload;
+}
+async function invokeAgent(client, body, flowId, agentId) {
+  const wf = wfOf(client);
+  if (!wf?.httpClient) return wf.invokeAgent({ ...body }, flowId, agentId);
+  const headers = { ...await wf.getHeaders(true) };
+  const post = async (url, data2) => {
+    try {
+      const res = await wf.httpClient.request({ method: "post", url, data: data2, headers });
+      const d = res?.data;
+      return d?.data && (d.data.reply !== void 0 || d.data.response !== void 0) ? d.data : d;
+    } catch (e) {
+      const r = e?.response;
+      const msg = r?.data?.message ?? r?.data?.error_message ?? r?.data?.detail ?? (typeof r?.data?.error === "string" ? r.data.error : null) ?? (typeof r?.data?.reply === "string" ? r.data.reply : null);
+      throw new Error(r?.status ? `Agent call failed (${r.status})${msg ? `: ${msg}` : ""}` : e?.message || "Agent call failed \u2014 check the network tab");
+    }
+  };
+  const agent = encodeURIComponent(String(agentId ?? ""));
+  let data = null;
+  if (flowId) {
+    data = await post(`/api/v1/zwall/agent/invoke/${encodeURIComponent(String(flowId))}/${agent}`, { ...body }).catch((e) => ({ error: true, reply: e.message }));
+    const unknownFlow = data?.error === true && typeof data?.reply === "string" && data.reply.includes(String(flowId));
+    if (!unknownFlow && data?.error !== true) return data;
+    if (!unknownFlow) throw new Error(typeof data?.reply === "string" && data.reply ? data.reply : data?.message ?? "The agent returned an error");
+  }
+  const content = { ...body?.content ?? {}, file_url: Array.isArray(body?.content?.file_url) ? body.content.file_url : [] };
+  data = await post(`/api/v1/zwall/v3/agent_manager/agent_flow/${agent}`, { ...body, content });
+  if (data?.error === true) throw new Error(typeof data?.reply === "string" && data.reply ? data.reply : data?.message ?? "The agent returned an error");
+  return data;
+}
+var parseMaybeJson = (v) => {
+  if (typeof v !== "string") return v;
+  const t = v.trim();
+  if (!t.startsWith("{") && !t.startsWith("[")) return v;
+  try {
+    return JSON.parse(t);
+  } catch {
+    return v;
+  }
+};
+function extractAgentFormData(reply) {
+  let node = parseMaybeJson(reply);
+  for (let d = 0; d < 5; d++) {
+    if (!node || typeof node !== "object" || Array.isArray(node)) return null;
+    const fd = parseMaybeJson(node.formData);
+    if (fd && typeof fd === "object" && !Array.isArray(fd)) return fd;
+    if (!("response" in node)) return Object.keys(node).length ? node : null;
+    node = parseMaybeJson(node.response);
+  }
+  return null;
+}
 function formDataOf(result) {
   let node = result;
   for (let d = 0; d < 4 && node; d++) {
@@ -6349,90 +6936,449 @@ async function searchPeople(client, el2, query) {
   const els = res?.data?.elements ?? res?.elements ?? res?.data?.data?.elements ?? [];
   return (Array.isArray(els) ? els : []).map((o) => ({ label: String(o.title ?? o.select), value: String(o.select), extra: o.subtitle ? [o.subtitle] : [], raw: o }));
 }
-
-// src/forms/useZvolvForm.ts
-var normalizeOptions = (raw2) => (Array.isArray(raw2) ? raw2 : []).map((o) => {
-  if (o == null) return null;
-  if (typeof o !== "object") return { label: String(o), value: String(o) };
-  const label = o.view ?? o.label ?? o.name ?? o.text ?? o.title ?? o.value ?? o.select;
-  const value = o.select ?? o.value ?? o.id ?? o.label ?? o.view ?? o.name;
-  return { label: String(label ?? ""), value, color: o.color };
-}).filter(Boolean);
-var numOr = (v) => v === void 0 || v === null || v === "" || isNaN(Number(v)) ? void 0 : Number(v);
-function toDayjsFormat(fmt, withTime) {
-  const f = typeof fmt === "string" && fmt.trim() ? fmt.trim() : withTime ? "dd/MM/yyyy HH:mm" : "dd/MM/yyyy";
-  return f.replace(/yyyy/g, "YYYY").replace(/yy/g, "YY").replace(/dd/g, "DD").replace(/(^|[^D])d(?!d)/g, "$1D").replace(/EEE+/g, "ddd").replace(/a/g, "A");
-}
-function acceptOf(el2) {
-  const a = el2.attributes?.allowedFileTypes ?? el2.properties?.allowedFileTypes;
-  if (!a) return el2.type === "UPLOAD_FILE_IMAGE" ? "image/*" : void 0;
-  const list = (Array.isArray(a) ? a : String(a).split(",")).map((s) => String(s).trim()).filter((s) => s && s !== "*" && s !== "*/*");
-  if (!list.length) return el2.type === "UPLOAD_FILE_IMAGE" ? "image/*" : void 0;
-  return list.map((s) => s.includes("/") || s.startsWith(".") ? s : `.${s}`).join(",");
-}
-var FormApiContext = React13__default.default.createContext(null);
-function useFormApi() {
-  const f = React13__default.default.useContext(FormApiContext);
-  if (!f) throw new Error("@zestl/zvolv-widgets: useFormApi must be used inside <ZvolvForm> or FormApiContext");
-  return f;
-}
-function useZvolvForm(args) {
-  const { formId, submissionId = null, definition: suppliedDef, defaultValues, hiddenFields, skipTypes } = args;
-  const mode = args.mode ?? (submissionId ? "EDIT" : "NEW");
-  const rt = useZvolvRuntime();
-  const client = rt.client;
-  const argsRef = React13.useRef(args);
-  argsRef.current = args;
-  const [definition, setDefinition] = React13.useState(null);
-  const [status, setStatus] = React13.useState("loading");
-  const [error, setError] = React13.useState(null);
-  const [values, setValues] = React13.useState({});
-  const [serverErrors, setServerErrors] = React13.useState({});
-  const [touched, setTouched] = React13.useState(/* @__PURE__ */ new Set());
-  const [submitAttempted, setSubmitAttempted] = React13.useState(false);
-  const [flagged, setFlagged] = React13.useState(/* @__PURE__ */ new Set());
-  const [submitting, setSubmitting] = React13.useState(false);
-  const [submitError, setSubmitError] = React13.useState(null);
-  const [submittedId, setSubmittedId] = React13.useState(null);
-  const [dirty, setDirty] = React13.useState(false);
-  const [busy, setBusy] = React13.useState(/* @__PURE__ */ new Set());
-  const initialRef = React13.useRef({});
-  const valuesRef = React13.useRef({});
-  valuesRef.current = values;
-  const sheetDefs = React13.useRef(/* @__PURE__ */ new Map());
-  const user = React13.useMemo(() => {
-    try {
-      return client?.auth?.userInstance ?? null;
-    } catch {
-      return null;
-    }
-  }, [client]);
-  const onBehalfName = React13.useCallback((v) => {
-    if (v == null || v === "") return "";
-    if (String(v) === "3122") return "Super Admin";
-    if (user && String(v) === currentUserId(user)) return String(user.name ?? user.userName ?? user.fullName ?? user.email ?? v);
-    return String(v);
-  }, [user]);
-  const loadKey = JSON.stringify([formId, submissionId, mode, !!suppliedDef]);
-  React13.useEffect(() => {
-    let alive = true;
-    setStatus("loading");
-    setError(null);
-    setSubmittedId(null);
-    setSubmitAttempted(false);
-    (async () => {
-      const normalised = Array.isArray(suppliedDef?.elements) && suppliedDef.elements.every((e) => "widthSpecified" in e);
-      let def = suppliedDef ? normalised ? { ...suppliedDef, uuid: suppliedDef.uuid || formId || "" } : normaliseForm(suppliedDef, formId) : null;
-      let submission;
-      if (submissionId && mode !== "NEW") {
-        const s = await fetchSubmission(client, submissionId);
-        submission = s.values;
-        if (!def && s.form?.elements.length) def = { ...s.form, uuid: formId || s.form.uuid };
-      }
-      if (!def) {
-        if (!formId) throw new Error("No form configured");
-        def = await fetchForm(client, formId);
-      }
+var optionKey = (v) => String(v && typeof v === "object" ? v.select ?? v.value ?? v.view : v ?? "");
+var isFilled = (v) => v != null && v !== "" && !(Array.isArray(v) && !v.length);
+function useFieldOptions(form, field2, opts = {}) {
+  const { debounceMs = 250, loadOn = "focus", autofillExtraLabels = false } = opts;
+  const el2 = field2.element;
+  const cfg = React14.useMemo(() => field2.kind === "lookup" ? lookupConfigOf(el2) : null, [field2.kind, el2]);
+  const people = field2.kind === "user" && !!(el2.properties?.jsonData || el2.properties?.searchType === "GENERIC_FORM_AUTO_SEARCH");
+  const elements = form.definition?.elements ?? [];
+  const rules = React14.useMemo(() => optionFilterRules(elements, field2.id), [elements, field2.id]);
+  const dep = React14.useMemo(() => cfg ? lookupDependencyFilters(cfg, rules, elements, form.values) : { filters: [], satisfied: true }, [cfg, rules, elements, form.values]);
+  const depKey = JSON.stringify(dep.filters);
+  const maxCount = cfg ? cfg.maxResults : field2.kind === "user" ? maxResultsOf(el2) : field2.multiple ? Infinity : 1;
+  const single = maxCount === 1;
+  const [search, setSearch] = React14.useState("");
+  const [q, setQ] = React14.useState("");
+  React14.useEffect(() => {
+    const t = setTimeout(() => setQ(search), debounceMs);
+    return () => clearTimeout(t);
+  }, [search, debounceMs]);
+  const [remote, setRemote] = React14.useState([]);
+  const [loading, setLoading] = React14.useState(false);
+  const [error, setError] = React14.useState(null);
+  const [opened, setOpened] = React14.useState(loadOn === "mount");
+  const [nonce, setNonce] = React14.useState(0);
+  const lastFetch = React14.useRef(0);
+  const maxAge = React14.useRef(1e4);
+  const waitingFor = React14.useMemo(() => {
+    if (!cfg || dep.satisfied || cfg.operator !== "$and") return null;
+    const missing = rules.find((r) => !isFilled(form.values[r.elementId]));
+    const lbl = missing ? form.field(missing.elementId)?.label : cfg.dynamicFilters[0]?.DependencyFieldLabel;
+    return lbl ? `Select ${lbl} first` : "Fill the fields this depends on first";
+  }, [cfg, dep.satisfied, rules, form]);
+  const depDriven = !!cfg && rules.length > 0 && dep.filters.length > 0;
+  const active = opened || depDriven || q !== "";
+  React14.useEffect(() => {
+    if (!cfg && !people) return;
+    if (cfg && (waitingFor || cfg.loadOnDependency && !dep.filters.length && rules.length)) {
+      setRemote([]);
+      return;
+    }
+    if (!active) return;
+    let alive = true;
+    setLoading(true);
+    setError(null);
+    lastFetch.current = Date.now();
+    const p = cfg ? fetchLookupOptions(form.client, cfg, dep.filters, q, maxAge.current) : searchPeople(form.client, el2, q);
+    maxAge.current = 1e4;
+    p.then((o) => {
+      if (!alive) return;
+      setRemote(o);
+      if (cfg && rules.length && dep.filters.length && !q && o.length === 1) autoPickRef.current(o[0], depKey);
+    }).catch((e) => {
+      if (alive) setError(e?.message ?? "Couldn't load options");
+    }).finally(() => {
+      if (alive) setLoading(false);
+    });
+    return () => {
+      alive = false;
+    };
+  }, [cfg, people, depKey, q, waitingFor, form.client, active, nonce]);
+  const refresh = React14.useCallback(() => {
+    maxAge.current = 0;
+    setOpened(true);
+    setNonce((n) => n + 1);
+  }, []);
+  const onFocus = React14.useCallback(() => {
+    if (!cfg && !people) return;
+    if (!opened) {
+      setOpened(true);
+      return;
+    }
+    if (cfg && Date.now() - lastFetch.current > 2e3) {
+      maxAge.current = 2e3;
+      setNonce((n) => n + 1);
+    } else if (people && !remote.length) setNonce((n) => n + 1);
+  }, [cfg, people, opened, remote.length]);
+  const prevDepKey = React14.useRef(null);
+  React14.useEffect(() => {
+    if (!cfg || !rules.length) return;
+    if (prevDepKey.current === null) {
+      prevDepKey.current = depKey;
+      return;
+    }
+    if (prevDepKey.current === depKey) return;
+    prevDepKey.current = depKey;
+    if (form.readOnly) return;
+    if (isFilled(form.values[field2.id])) form.setValue(field2.id, single ? null : []);
+  }, [depKey]);
+  const staticFiltered = React14.useMemo(() => {
+    if (cfg || people) return remote;
+    const needle = search.trim().toLowerCase();
+    return needle ? field2.options.filter((o) => o.label.toLowerCase().includes(needle)) : field2.options;
+  }, [cfg, people, remote, field2.options, search]);
+  const pickedCache = React14.useRef(/* @__PURE__ */ new Map());
+  const current = field2.value;
+  const selected = React14.useMemo(() => {
+    const arr = current == null || current === "" ? [] : Array.isArray(current) ? current : [current];
+    const pool = [...staticFiltered, ...field2.options];
+    return arr.map((v) => {
+      const hit = pool.find((o) => optionKey(o.value) === optionKey(v)) ?? pickedCache.current.get(optionKey(v));
+      if (hit) return hit;
+      if (v && typeof v === "object") return { label: String(v.view ?? v.select ?? ""), value: String(v.select ?? v.view ?? ""), extra: v.extraLabels, raw: v };
+      return { label: String(v), value: v };
+    });
+  }, [current, staticFiltered, field2.options]);
+  const store = React14.useCallback((picked) => {
+    picked.forEach((o) => pickedCache.current.set(optionKey(o.value), o));
+    const t = field2.type;
+    if (field2.kind === "lookup") {
+      const rel = picked.map((o) => o.raw ?? { view: o.label, select: o.value, extraLabels: o.extra ?? [] });
+      form.setValue(field2.id, single ? rel[0] ?? null : rel.slice(0, maxCount));
+      if (autofillExtraLabels && cfg && picked.length === 1 && cfg.extraLabels.length) {
+        const fill2 = {};
+        cfg.extraLabels.forEach((label, i) => {
+          const target = (form.definition?.elements ?? []).find((e) => e.label === label && e.elementId !== field2.id);
+          const v = picked[0].extra?.[i];
+          if (target && v !== void 0) fill2[target.elementId] = v;
+        });
+        if (Object.keys(fill2).length) form.applyValues(fill2);
+      }
+      return;
+    }
+    if (field2.multiple) form.setValue(field2.id, picked.slice(0, maxCount).map((o) => o.value));
+    else form.setValue(field2.id, picked[0]?.value ?? (t === "CHECK_BOX" ? false : ""));
+  }, [field2, form, cfg, single, maxCount, autofillExtraLabels]);
+  const autoPickRef = React14.useRef(() => {
+  });
+  const lastAutoKey = React14.useRef(null);
+  autoPickRef.current = (o, key) => {
+    if (form.readOnly || lastAutoKey.current === key) return;
+    lastAutoKey.current = key;
+    if (isFilled(form.values[field2.id])) return;
+    store([o]);
+  };
+  const select = React14.useCallback((o) => store(o == null ? [] : Array.isArray(o) ? o : [o]), [store]);
+  const isSelected = React14.useCallback((o) => selected.some((s) => optionKey(s.value) === optionKey(o.value)), [selected]);
+  const atLimit = field2.multiple && selected.length >= maxCount;
+  const toggle = React14.useCallback((o) => {
+    const on = isSelected(o);
+    if (!on && field2.multiple && selected.length >= maxCount) return;
+    store(on ? selected.filter((s) => optionKey(s.value) !== optionKey(o.value)) : field2.multiple ? [...selected, o] : [o]);
+  }, [isSelected, selected, store, field2.multiple, maxCount]);
+  const addFreeTag = React14.useCallback((text2) => {
+    const t = text2.trim();
+    if (!t || field2.type !== "INPUT_TAG") return;
+    const o = { label: t, value: t, extra: [], raw: { view: t, select: t, extraLabels: [] } };
+    if (selected.some((s) => optionKey(s.value) === t)) return;
+    if (field2.multiple) {
+      if (selected.length < maxCount) store([...selected, o]);
+    } else store([o]);
+    setSearch("");
+  }, [field2.type, field2.multiple, selected, maxCount, store]);
+  return {
+    options: staticFiltered,
+    loading,
+    error,
+    search,
+    setSearch,
+    waitingFor,
+    selected,
+    select,
+    toggle,
+    isSelected,
+    onFocus,
+    refresh,
+    maxCount,
+    atLimit,
+    addFreeTag
+  };
+}
+var BLOCKED_FILE_EXTENSIONS = new Set("ade adp app application appref-ms asp aspx asx bas bat bgi cab cer chm cmd cnt com cpl crt csh der diagcab exe fxp gadget grp hlp hpj hta htc inf ins iso isp its jar jnlp js jse ksh lnk mad maf mag mam maq mar mas mat mau mav maw mcf mda mdb mde mdt mdw mdz msc msh msh1 msh2 mshxml msh1xml msh2xml msi msp mst msu ops osd pcd pif pl plg prf ps1 ps1xml ps2 ps2xml psc1 psc2 reg scr scf sln vbs vb vbe ws wsf wsc wsh z bz2 ace ppkg bak tmp ost pst pkg vhd vhdx lock lck cs csproj resx config resources pdb manifest dot wbk xlt xlm xla pot pps cdb mdn sh php mdf py ldb wps xlsb xlam xll xlw ppam".split(" "));
+function useFileField(form, field2, opts = {}) {
+  const stored = Array.isArray(field2.value) ? field2.value : [];
+  const [pending2, setPending] = React14.useState([]);
+  const [reject, setReject] = React14.useState(null);
+  const storedRef = React14.useRef(stored);
+  storedRef.current = stored;
+  const items = [
+    ...stored.map((r, i) => ({
+      key: `s${i}:${r.media_name ?? r.mediaName ?? r.name}`,
+      name: String(r.media_name ?? r.mediaName ?? r.name ?? "file"),
+      size: Number(r.media_size ?? r.mediaSize ?? r.size ?? 0),
+      type: String(r.media_type ?? r.mediaType ?? r.type ?? ""),
+      url: r.media ?? r.url,
+      uploading: false,
+      record: r
+    })),
+    ...pending2
+  ];
+  const max = field2.maxCount;
+  const add = React14.useCallback((list) => {
+    setReject(null);
+    const files = Array.from(list);
+    const room = max ? Math.max(0, max - storedRef.current.length - pending2.filter((p) => p.uploading).length) : files.length;
+    if (!room) {
+      setReject(`You can attach up to ${max} file${max === 1 ? "" : "s"}`);
+      return;
+    }
+    files.slice(0, room).forEach((file) => {
+      const ext = file.name.includes(".") ? file.name.split(".").pop().toLowerCase() : "";
+      if (ext && BLOCKED_FILE_EXTENSIONS.has(ext)) {
+        setReject(`Cannot upload files with the extension .${ext}`);
+        return;
+      }
+      if (field2.maxSizeKB && file.size > field2.maxSizeKB * 1024) {
+        setReject(`${file.name} is larger than ${Math.round(field2.maxSizeKB / 1024 * 10) / 10 || field2.maxSizeKB} ${field2.maxSizeKB >= 1024 ? "MB" : "KB"}`);
+        return;
+      }
+      const accept = field2.accept?.split(",").map((s) => s.trim().toLowerCase()).filter(Boolean);
+      if (accept?.length && !accept.some((a) => a.endsWith("/*") ? file.type.startsWith(a.slice(0, -1)) : a.startsWith(".") ? file.name.toLowerCase().endsWith(a) : file.type === a)) {
+        setReject(`${file.name} isn't an allowed file type`);
+        return;
+      }
+      const key = `p${Date.now()}${Math.random()}`;
+      setPending((p) => [...p, { key, name: file.name, size: file.size, type: file.type, uploading: true }]);
+      uploadFile(form.client, field2.element, file, opts.zappId).then((rec) => {
+        setPending((p) => p.filter((x) => x.key !== key));
+        const next = [...storedRef.current, rec];
+        storedRef.current = next;
+        form.setValue(field2.id, next);
+      }).catch((e) => setPending((p) => p.map((x) => x.key === key ? { ...x, uploading: false, error: e?.message ?? "Upload failed" } : x)));
+    });
+    if (files.length > room) setReject(`Only ${room} more file${room === 1 ? "" : "s"} can be attached`);
+  }, [form, field2, max, pending2, opts.zappId]);
+  const remove = React14.useCallback((key) => {
+    if (key.startsWith("p")) {
+      setPending((p) => p.filter((x) => x.key !== key));
+      return;
+    }
+    const idx = items.findIndex((i) => i.key === key);
+    if (idx < 0) return;
+    const next = storedRef.current.filter((_2, i) => i !== idx);
+    form.setValue(field2.id, next.length ? next : []);
+  }, [items, form, field2.id]);
+  return { items, uploading: pending2.some((p) => p.uploading), add, remove, canAdd: !field2.disabled && (!max || stored.length < max), rejectReason: reject };
+}
+function sheetAllows(p, action) {
+  const specific = action === "ADD" ? p?.allowedAddActions : p?.allowedDeleteActions;
+  const list = Array.isArray(specific) && specific.length ? specific : p?.allowedActions;
+  if (!Array.isArray(list) || !list.length) return true;
+  return list.map((x) => String(x).toUpperCase()).includes(action);
+}
+function useSheetField(form, field2) {
+  const childId = String(field2.element.properties?.formID ?? field2.element.properties?.FormID ?? field2.element.properties?.nestedFormId ?? field2.element.properties?.dataSource?.FormID ?? "");
+  const [child, setChild] = React14.useState(null);
+  const [loading, setLoading] = React14.useState(!!childId);
+  const [error, setError] = React14.useState(childId ? null : "No child form configured");
+  React14.useEffect(() => {
+    if (!childId) return;
+    let alive = true;
+    setLoading(true);
+    fetchForm(form.client, childId).then(async (def) => {
+      if (!alive) return;
+      setChild(def);
+      form.registerSheet(field2.id, def);
+      const raw2 = Array.isArray(field2.value) ? field2.value : [];
+      const ids = raw2.filter((r) => typeof r === "string" || typeof r === "number").map(String);
+      if (ids.length) {
+        const rows2 = await fetchRows(form.client, childId, ids);
+        if (alive) form.applyValues({ [field2.id]: rows2 });
+      }
+    }).catch((e) => alive && setError(e?.message ?? "Couldn't load the table")).finally(() => alive && setLoading(false));
+    return () => {
+      alive = false;
+    };
+  }, [childId, form.client]);
+  const columns = React14.useMemo(() => (child?.elements ?? []).filter((e) => !e.hidden && !["COLLAPSE_SECTION", "CONTAINER", "GROUP_VIEW", "TEXT_VIEW", "ACTION_BUTTON"].includes(resolveFieldType(e))).map((e) => ({
+    id: e.elementId,
+    label: e.label,
+    type: resolveFieldType(e),
+    required: e.required,
+    element: e,
+    options: (Array.isArray(e.properties?.options) ? e.properties.options : []).map((o) => typeof o === "object" ? { label: String(o.view ?? o.label ?? o.select), value: o.select ?? o.value } : { label: String(o), value: o })
+  })), [child]);
+  const rows = (Array.isArray(field2.value) ? field2.value : []).filter((r) => r && typeof r === "object");
+  const p = field2.element.properties ?? {};
+  const maxRows = Number(p.maxRows) > 0 ? Number(p.maxRows) : void 0;
+  const [limitMessage, setLimitMessage] = React14.useState(null);
+  const addAllowed = !field2.disabled && sheetAllows(p, "ADD");
+  const canDelete = !field2.disabled && sheetAllows(p, "DELETE");
+  const addRow = React14.useCallback((vals) => {
+    if (!addAllowed) return;
+    if (maxRows && rows.length >= maxRows) {
+      setLimitMessage(`Maximum number of rows reached (${maxRows})`);
+      return;
+    }
+    setLimitMessage(null);
+    const blank = child ? computeRowFormulas(child.elements, buildInitialValues(child.elements, { defaults: vals })) : { ...vals ?? {} };
+    form.setValue(field2.id, [...rows, { ...blank, _rowKey: `r${Date.now()}${Math.random()}` }]);
+  }, [child, rows, form, field2.id, addAllowed, maxRows]);
+  const updateRow = React14.useCallback((i, col, v) => {
+    const recalc = (r) => child ? computeRowFormulas(child.elements, r) : r;
+    form.setValue(field2.id, rows.map((r, j) => j === i ? recalc({ ...r, [col]: v, _dirty: true }) : r));
+  }, [rows, form, field2.id, child]);
+  const removeRow = React14.useCallback((i) => {
+    if (!canDelete) return;
+    setLimitMessage(null);
+    form.setValue(field2.id, rows.filter((_2, j) => j !== i));
+  }, [rows, form, field2.id, canDelete]);
+  const rowErrors = React14.useMemo(() => {
+    const out = {};
+    if (!form.submitAttempted) return out;
+    rows.forEach((r, i) => {
+      if (!sheetRowNeedsCheck(r)) return;
+      columns.forEach((c) => {
+        if (!sheetCellChecked(c.element)) return;
+        const e = validateField(c.element, r[c.id]);
+        if (e) out[`${i}:${c.id}`] = e;
+      });
+    });
+    return out;
+  }, [rows, columns, form.submitAttempted]);
+  return {
+    loading,
+    error,
+    columns,
+    rows,
+    addRow,
+    updateRow,
+    removeRow,
+    rowErrors,
+    childForm: child,
+    canAdd: addAllowed && (!maxRows || rows.length < maxRows),
+    canDelete,
+    maxRows,
+    limitMessage,
+    display: (c, v) => formatFieldValue(c.element, v)
+  };
+}
+
+// src/forms/useZvolvForm.ts
+function submitElementsOf(elements) {
+  const always = /* @__PURE__ */ new Set(["INPUT_FORMULA", "ON_BEHALF_OF", "INPUT_IP", "INPUT_DEVICE_INFO"]);
+  return elements.filter((el2) => {
+    const t = resolveFieldType(el2);
+    return !NON_INPUT_TYPES.has(t) || always.has(t);
+  });
+}
+var normalizeOptions = (raw2) => (Array.isArray(raw2) ? raw2 : []).map((o) => {
+  if (o == null) return null;
+  if (typeof o !== "object") return { label: String(o), value: String(o) };
+  const label = o.view ?? o.label ?? o.name ?? o.text ?? o.title ?? o.value ?? o.select;
+  const value = o.select ?? o.value ?? o.id ?? o.label ?? o.view ?? o.name;
+  return { label: String(label ?? ""), value, color: o.color };
+}).filter(Boolean);
+var isActionDropdown = (el2) => el2.attributes?.subType === "ACTION_DROPDOWN" || String(el2.type).toUpperCase() === "ACTION_DROPDOWN";
+var isEncString = (v) => typeof v === "string" && v.startsWith("enc::");
+var numOr = (v) => v === void 0 || v === null || v === "" || isNaN(Number(v)) ? void 0 : Number(v);
+function toDayjsFormat(fmt2, withTime) {
+  const f = typeof fmt2 === "string" && fmt2.trim() ? fmt2.trim() : withTime ? "dd/MM/yyyy HH:mm" : "dd/MM/yyyy";
+  return f.replace(/yyyy/g, "YYYY").replace(/yy/g, "YY").replace(/dd/g, "DD").replace(/(^|[^D])d(?!d)/g, "$1D").replace(/EEE+/g, "ddd").replace(/a/g, "A");
+}
+function acceptOf(el2) {
+  const a = el2.attributes?.allowedFileTypes ?? el2.properties?.allowedFileTypes;
+  if (!a) return el2.type === "UPLOAD_FILE_IMAGE" ? "image/*" : void 0;
+  const list = (Array.isArray(a) ? a : String(a).split(",")).map((s) => String(s).trim()).filter((s) => s && s !== "*" && s !== "*/*");
+  if (!list.length) return el2.type === "UPLOAD_FILE_IMAGE" ? "image/*" : void 0;
+  return list.map((s) => s.includes("/") || s.startsWith(".") ? s : `.${s}`).join(",");
+}
+var FormApiContext = React14__default.default.createContext(null);
+function useFormApi() {
+  const f = React14__default.default.useContext(FormApiContext);
+  if (!f) throw new Error("@zestl/zvolv-widgets: useFormApi must be used inside <ZvolvForm> or FormApiContext");
+  return f;
+}
+function useZvolvForm(args) {
+  const { formId, submissionId = null, definition: suppliedDef, defaultValues, hiddenFields, skipTypes } = args;
+  const mode = args.mode ?? (submissionId ? "EDIT" : "NEW");
+  const rt = useZvolvRuntime();
+  const client = rt.client;
+  const argsRef = React14.useRef(args);
+  argsRef.current = args;
+  const [definition, setDefinition] = React14.useState(null);
+  const [status, setStatus] = React14.useState("loading");
+  const [error, setError] = React14.useState(null);
+  const [values, setValues] = React14.useState({});
+  const [serverErrors, setServerErrors] = React14.useState({});
+  const [touched, setTouched] = React14.useState(/* @__PURE__ */ new Set());
+  const [submitAttempted, setSubmitAttempted] = React14.useState(false);
+  const [flagged, setFlagged] = React14.useState(/* @__PURE__ */ new Set());
+  const [submitting, setSubmitting] = React14.useState(false);
+  const [submitError, setSubmitError] = React14.useState(null);
+  const [submittedId, setSubmittedId] = React14.useState(null);
+  const [dirty, setDirty] = React14.useState(false);
+  const [busy, setBusy] = React14.useState(/* @__PURE__ */ new Set());
+  const initialRef = React14.useRef({});
+  const valuesRef = React14.useRef({});
+  valuesRef.current = values;
+  const sheetDefs = React14.useRef(/* @__PURE__ */ new Map());
+  const [userTick, setUserTick] = React14.useState(0);
+  React14.useEffect(() => {
+    if (typeof window === "undefined") return;
+    const bump = () => setUserTick((n) => n + 1);
+    window.addEventListener(AUTH_CRYPT_READY, bump);
+    return () => window.removeEventListener(AUTH_CRYPT_READY, bump);
+  }, []);
+  const user = React14.useMemo(() => getStoredUser() ?? null, [client, userTick]);
+  React14.useEffect(() => {
+    if (status !== "ready" || mode !== "NEW") return;
+    const uid = currentUserId(user);
+    if (!uid) return;
+    const fill2 = {};
+    (definition?.elements ?? []).forEach((el2) => {
+      const v = valuesRef.current[el2.elementId];
+      if (resolveFieldType(el2) === "ON_BEHALF_OF" && (v == null || v === "" || isEncString(v))) fill2[el2.elementId] = uid;
+    });
+    if (Object.keys(fill2).length) setValues((p) => {
+      const m = { ...p, ...fill2 };
+      valuesRef.current = m;
+      return m;
+    });
+  }, [user, status]);
+  const onBehalfName = React14.useCallback((v) => {
+    if (v == null || v === "") return "";
+    if (String(v) === "3122") return "Super Admin";
+    if (isEncString(v)) return "";
+    if (user && String(v) === currentUserId(user)) {
+      const name = user.name ?? user.userName ?? user.fullName ?? user.profile?.name ?? user.email;
+      return name ? String(name) : String(v);
+    }
+    return String(v);
+  }, [user]);
+  const [reloadTick, setReloadTick] = React14.useState(0);
+  const loadKey = JSON.stringify([formId, submissionId, mode, !!suppliedDef, reloadTick]);
+  React14.useEffect(() => {
+    let alive = true;
+    setStatus("loading");
+    setError(null);
+    setSubmittedId(null);
+    setSubmitAttempted(false);
+    (async () => {
+      const normalised = Array.isArray(suppliedDef?.elements) && suppliedDef.elements.every((e) => "widthSpecified" in e);
+      let def = suppliedDef ? normalised ? { ...suppliedDef, uuid: suppliedDef.uuid || formId || "" } : normaliseForm(suppliedDef, formId) : null;
+      let submission;
+      if (submissionId && mode !== "NEW") {
+        const s = await fetchSubmission(client, submissionId);
+        submission = s.values;
+        if (!def && s.form?.elements.length) def = { ...s.form, uuid: formId || s.form.uuid };
+      }
+      if (!def) {
+        if (!formId) throw new Error("No form configured");
+        def = await fetchForm(client, formId);
+      }
       const init = buildInitialValues(def.elements, { defaults: argsRef.current.defaultValues, submission, user });
       if (def.elements.some((e) => resolveFieldType(e) === "INPUT_IP")) {
         const info = await clientInfo(client);
@@ -6463,13 +7409,13 @@ function useZvolvForm(args) {
     };
   }, [loadKey, client]);
   const elements = definition?.elements ?? [];
-  const byId = React13.useMemo(() => new Map(elements.map((e) => [e.elementId, e])), [elements]);
-  const labels = React13.useMemo(() => elements.map((e) => e.label).filter(Boolean), [elements]);
-  const overrides = React13.useMemo(() => applyRules(elements, values), [elements, values]);
+  const byId = React14.useMemo(() => new Map(elements.map((e) => [e.elementId, e])), [elements]);
+  const labels = React14.useMemo(() => elements.map((e) => e.label).filter(Boolean), [elements]);
+  const overrides = React14.useMemo(() => applyRules(elements, values), [elements, values]);
   const readOnly = mode === "DISABLED" || !!definition?.configurations?.editingLocked;
-  const hiddenSet = React13.useMemo(() => new Set(hiddenFields ?? []), [hiddenFields]);
-  const skipSet = React13.useMemo(() => new Set((skipTypes ?? []).map((s) => s.toUpperCase())), [skipTypes]);
-  const hiddenByParent = React13.useMemo(() => {
+  const hiddenSet = React14.useMemo(() => new Set(hiddenFields ?? []), [hiddenFields]);
+  const skipSet = React14.useMemo(() => new Set((skipTypes ?? []).map((s) => s.toUpperCase())), [skipTypes]);
+  const hiddenByParent = React14.useMemo(() => {
     const out = /* @__PURE__ */ new Set();
     const visit = (el2) => childIdsOf(el2).forEach((id) => {
       if (out.has(id)) return;
@@ -6484,7 +7430,7 @@ function useZvolvForm(args) {
     });
     return out;
   }, [elements, overrides, byId]);
-  const stateOf = React13.useCallback((el2) => {
+  const stateOf = React14.useCallback((el2) => {
     const o = overrides.get(el2.elementId) ?? {};
     return {
       hidden: hiddenByParent.has(el2.elementId) || (o.isHidden ?? el2.hidden),
@@ -6492,7 +7438,7 @@ function useZvolvForm(args) {
       required: o.isRequired ?? el2.required
     };
   }, [overrides, readOnly, hiddenByParent]);
-  React13.useEffect(() => {
+  React14.useEffect(() => {
     if (status !== "ready") return;
     const formulas = elements.filter((e) => resolveFieldType(e) === "INPUT_FORMULA" && e.properties?.formula);
     if (!formulas.length) return;
@@ -6514,7 +7460,7 @@ function useZvolvForm(args) {
     });
     if (Object.keys(next).length) setValues((prev) => ({ ...prev, ...next }));
   }, [values, elements, labels, status]);
-  const applyValues = React13.useCallback((data) => {
+  const applyValues = React14.useCallback((data) => {
     if (!data || typeof data !== "object") return;
     const loose = (s) => String(s).toLowerCase().replace(/[^a-z0-9]+/g, "");
     const index = /* @__PURE__ */ new Map();
@@ -6538,7 +7484,7 @@ function useZvolvForm(args) {
       return merged;
     });
   }, [elements]);
-  const withBusy = React13.useCallback(async (id, fn) => {
+  const withBusy = React14.useCallback(async (id, fn) => {
     setBusy((b) => new Set(b).add(id));
     try {
       return await fn();
@@ -6550,11 +7496,11 @@ function useZvolvForm(args) {
       });
     }
   }, []);
-  const triggerBody = React13.useCallback(
+  const triggerBody = React14.useCallback(
     (vals) => buildTriggerBody(elements, vals, { formId: definition?.uuid ?? formId, submissionId: submissionId ?? submittedId }),
     [elements, definition, formId, submissionId, submittedId]
   );
-  const runFieldAutomations = React13.useCallback((el2, vals) => {
+  const runFieldAutomations = React14.useCallback((el2, vals) => {
     if (argsRef.current.skipAutomation) return;
     const acts = (el2.properties?.actions ?? []).filter((a) => String(a?.type ?? "").toUpperCase() === "TRIGGER_AUTOMATION" && (a.triggerID ?? a.triggerId));
     acts.forEach((a) => {
@@ -6570,7 +7516,7 @@ function useZvolvForm(args) {
       });
     });
   }, [client, triggerBody, applyValues, withBusy]);
-  const setValue = React13.useCallback((id, value) => {
+  const setValue = React14.useCallback((id, value) => {
     const el2 = byId.get(id);
     const next = { ...valuesRef.current, [id]: value };
     valuesRef.current = next;
@@ -6590,16 +7536,16 @@ function useZvolvForm(args) {
       if (other.elementId !== id && Array.isArray(watch) && watch.map(String).includes(id)) runFieldAutomations(other, next);
     });
   }, [byId, elements, runFieldAutomations]);
-  const touch = React13.useCallback((id) => setTouched((t) => t.has(id) ? t : new Set(t).add(id)), []);
-  const clientErrors = React13.useMemo(
+  const touch = React14.useCallback((id) => setTouched((t) => t.has(id) ? t : new Set(t).add(id)), []);
+  const clientErrors = React14.useMemo(
     () => validateForm(elements, values, (el2) => {
       const s = stateOf(el2);
       return { hidden: s.hidden || hiddenSet.has(el2.elementId) || hiddenSet.has(el2.label), required: s.required };
     }),
     [elements, values, stateOf, hiddenSet]
   );
-  const errors = React13.useMemo(() => ({ ...clientErrors, ...Object.fromEntries(Object.entries(serverErrors).filter(([, v]) => v)) }), [clientErrors, serverErrors]);
-  const validate = React13.useCallback((ids) => {
+  const errors = React14.useMemo(() => ({ ...clientErrors, ...Object.fromEntries(Object.entries(serverErrors).filter(([, v]) => v)) }), [clientErrors, serverErrors]);
+  const validate = React14.useCallback((ids) => {
     const keys = ids ?? Object.keys(errors);
     if (ids) setTouched((t) => {
       const n = new Set(t);
@@ -6615,7 +7561,7 @@ function useZvolvForm(args) {
     });
     return !bad.length;
   }, [errors]);
-  const fields = React13.useMemo(() => elements.map((el2) => {
+  const fields = React14.useMemo(() => elements.map((el2) => {
     const t = resolveFieldType(el2);
     const kind = fieldKindOf(el2);
     const s = stateOf(el2);
@@ -6640,7 +7586,7 @@ function useZvolvForm(args) {
       value: values[el2.elementId],
       error: showErr ? errors[el2.elementId] : void 0,
       touched: touched.has(el2.elementId),
-      options: normalizeOptions(p.options),
+      options: kind === "action" && isActionDropdown(el2) ? (p.actionEleIds ?? []).map((id) => byId.get(String(id))).filter(Boolean).map((o) => ({ label: o.label, value: o.label })) : normalizeOptions(p.options),
       multiple: kind === "lookup" || kind === "user" ? !isSingleLookup(el2) : false,
       allowAddOptions: !!p.allowAddOptions,
       min: numericKind ? numOr(p.minVal ?? p.min) ?? (t === "INPUT_PERCENT" || kind === "slider" ? 0 : kind === "rating" ? 1 : void 0) : void 0,
@@ -6655,7 +7601,7 @@ function useZvolvForm(args) {
       childIds: CONTAINER_KINDS.has(kind) ? childIdsOf(el2) : [],
       pages: pagesRaw.length ? pagesRaw.map((pg, i) => ({ title: pg.title ?? pg.label ?? `Step ${i + 1}`, description: pg.description, fieldIds: pg.childElements ?? [] })) : void 0,
       html: kind === "display" ? String(values[el2.elementId] ?? el2.defaultValue ?? p.text ?? "") : void 0,
-      variant: kind === "action" ? a.outline ? "outline" : "primary" : kind === "checkbox" && (a.showAsSwitch || p.showAsSwitch) ? "switch" : void 0,
+      variant: kind === "action" && isActionDropdown(el2) ? "dropdown" : kind === "action" ? a.outline ? "outline" : "primary" : kind === "checkbox" && (a.showAsSwitch || p.showAsSwitch) ? "switch" : void 0,
       displayText: kind === "onbehalf" ? onBehalfName(values[el2.elementId]) : void 0,
       dateFormat: kind === "date" || kind === "datetime" ? toDayjsFormat(p.format, kind === "datetime") : void 0,
       maxLength: kind === "text" || kind === "textarea" || kind === "richtext" ? numOr(p.maxLength ?? p.max ?? (kind === "richtext" ? a.charactersCount : void 0)) : void 0,
@@ -6665,18 +7611,18 @@ function useZvolvForm(args) {
     };
     return f;
   }), [elements, values, errors, stateOf, touched, flagged, serverErrors, hiddenSet, skipSet, setValue, touch, onBehalfName]);
-  const fieldMap2 = React13.useMemo(() => new Map(fields.map((f) => [f.id, f])), [fields]);
-  const claimed = React13.useMemo(() => {
+  const fieldMap2 = React14.useMemo(() => new Map(fields.map((f) => [f.id, f])), [fields]);
+  const claimed = React14.useMemo(() => {
     const s = /* @__PURE__ */ new Set();
     fields.forEach((f) => f.childIds.forEach((c) => s.add(c)));
     return s;
   }, [fields]);
-  const rootFields = React13.useMemo(() => fields.filter((f) => !claimed.has(f.id) && !f.hidden && f.kind !== "unknown"), [fields, claimed]);
-  const childrenOf = React13.useCallback((f, visibleOnly = true) => {
+  const rootFields = React14.useMemo(() => fields.filter((f) => !claimed.has(f.id) && !f.hidden && f.kind !== "unknown"), [fields, claimed]);
+  const childrenOf = React14.useCallback((f, visibleOnly = true) => {
     const ff = typeof f === "string" ? fieldMap2.get(f) : f;
     return (ff?.childIds ?? []).map((id) => fieldMap2.get(id)).filter((c) => !!c && (!visibleOnly || !c.hidden));
   }, [fieldMap2]);
-  const runRemoteValidation = React13.useCallback(async (vals) => {
+  const runRemoteValidation = React14.useCallback(async (vals) => {
     if (argsRef.current.skipValidations) return {};
     const out = {};
     for (const el2 of elements) {
@@ -6698,7 +7644,7 @@ function useZvolvForm(args) {
     }
     return out;
   }, [elements, stateOf, client, triggerBody, definition]);
-  const postSheetRows = React13.useCallback(async (vals, parentId) => {
+  const postSheetRows = React14.useCallback(async (vals, parentId) => {
     const out = { ...vals };
     for (const el2 of elements) {
       const t = resolveFieldType(el2);
@@ -6714,11 +7660,12 @@ function useZvolvForm(args) {
           saved.push(row);
           continue;
         }
-        const { _submissionId, _dirty, _rowKey, ...cells } = row;
+        const { _submissionId, _dirty, _rowKey, ...raw2 } = row;
         if (_submissionId && !_dirty) {
           saved.push(row);
           continue;
         }
+        const cells = computeRowFormulas(child.elements, raw2);
         const res = _submissionId ? await updateSubmission(client, child, _submissionId, child.elements, cells) : await createSubmission(client, child, child.elements, cells, { parentSubmissionId: parentId });
         saved.push({ ...cells, _submissionId: _submissionId ?? submissionIdOf(res) });
       }
@@ -6726,7 +7673,7 @@ function useZvolvForm(args) {
     }
     return out;
   }, [elements, client]);
-  const submit = React13.useCallback(async () => {
+  const submit = React14.useCallback(async () => {
     if (!definition || readOnly) return null;
     setSubmitAttempted(true);
     setSubmitError(null);
@@ -6749,7 +7696,7 @@ function useZvolvForm(args) {
       }
       const vals = await postSheetRows(valuesRef.current, submissionId ?? void 0);
       const opts = { skipAutomation: argsRef.current.skipAutomation, skipValidations: argsRef.current.skipValidations };
-      const submitEls = elements.filter((el2) => !NON_INPUT_TYPES.has(resolveFieldType(el2)) || resolveFieldType(el2) === "INPUT_FORMULA" || resolveFieldType(el2) === "ON_BEHALF_OF" || resolveFieldType(el2) === "INPUT_IP" || resolveFieldType(el2) === "INPUT_DEVICE_INFO");
+      const submitEls = submitElementsOf(elements);
       const response = submissionId && mode !== "NEW" ? await updateSubmission(client, definition, submissionId, submitEls, vals, opts) : await createSubmission(client, definition, submitEls, vals, opts);
       const newId = submissionId && mode !== "NEW" ? submissionId : submissionIdOf(response);
       setValues(vals);
@@ -6765,446 +7712,411 @@ function useZvolvForm(args) {
       setSubmitting(false);
     }
   }, [definition, readOnly, clientErrors, runRemoteValidation, mode, postSheetRows, submissionId, elements, client]);
-  const reset = React13.useCallback(() => {
+  const reset = React14.useCallback(() => {
     setValues(initialRef.current);
     setTouched(/* @__PURE__ */ new Set());
     setFlagged(/* @__PURE__ */ new Set());
     setServerErrors({});
-    setSubmitAttempted(false);
-    setSubmitError(null);
-    setDirty(false);
-    if (definition) setStatus("ready");
-  }, [definition]);
-  const apiRef = React13.useRef(null);
-  const runAction = React13.useCallback(async (field2) => {
-    const p = field2.element.properties ?? {};
-    const subType = String(field2.element.attributes?.subType ?? "");
-    const rawType = p.actionType ?? p.subType ?? (subType && subType !== field2.element.type && subType !== field2.type ? subType : "");
-    const actionType = String(rawType ?? "").toUpperCase();
-    if (field2.type === "CASCADED_ACTIONS") {
-      for (const id of p.actionEleIds ?? []) {
-        const f = fieldMap2.get(String(id));
-        if (f) {
-          const r2 = await runAction(f);
-          if (!r2.ok) return r2;
-        }
-      }
-      if (p.submit) await submit();
-      return { ok: true };
-    }
-    const handled = await argsRef.current.onAction?.(field2, apiRef.current);
-    if (handled) return handled;
-    const trig = p.triggerID ?? p.triggerId ?? p.TriggerID ?? p.automationId;
-    const isTrigger = actionType === "TRIGGER_AUTOMATION" || actionType === "TRIGGER" || field2.type === "TRIGGER_AUTOMATION" || field2.type === "INPUT_TRIGGER" || !actionType && !!trig;
-    if (isTrigger) {
-      if (!trig) return { ok: false, message: "No automation is linked to this button" };
-      return withBusy(field2.id, async () => {
-        try {
-          const res = await invokeTrigger(client, trig, triggerBody(valuesRef.current));
-          const fd = formDataOf(res);
-          if (fd) applyValues(fd);
-          const failed = res?.comment?.type === "error" || res?.error || res?.code === 500 || res?.code === 400;
-          if (failed) return { ok: false, message: res?.comment?.message ?? res?.message ?? p.errorMessage ?? "Action failed" };
-          return { ok: true, message: p.hideSuccessMessage ? void 0 : p.successMessage ?? res?.comment?.message ?? res?.message };
-        } catch (e) {
-          return { ok: false, message: p.errorMessage ?? e?.message ?? "Action failed" };
-        }
-      });
-    }
-    if (!actionType || actionType === "OPEN_URL" || actionType === "URL") {
-      const url = p.url ?? p.link ?? field2.value ?? field2.element.defaultValue;
-      if (url && typeof url === "string" && typeof window !== "undefined") window.open(url, "_blank", "noopener");
-      return { ok: !!url, message: url ? void 0 : "No link configured" };
-    }
-    if (actionType === "SUBMIT" || p.SubmitButton) {
-      const r2 = await submit();
-      return { ok: !!r2, message: r2 ? p.successMessage : void 0 };
-    }
-    const HOST = [
-      "SAVE_SUBMISSION",
-      "CREATE_SUBMISSION",
-      "EDIT_SUBMISSION",
-      "OPEN_TASK",
-      "PRINT_PREVIEW",
-      "DOWNLOAD_FILE",
-      "UPLOAD_FILE",
-      "OPEN_PROJECT",
-      "INVOKE_AGENT",
-      "AGENT",
-      "FLOW"
-    ];
-    if (HOST.includes(actionType)) {
-      return { ok: false, message: `"${field2.label}" (${actionType}) needs the app to handle it \u2014 pass onAction to <ZvolvForm>` };
-    }
-    setValue(field2.id, true);
-    const r = await submit();
-    return { ok: !!r, message: r ? p.successMessage : void 0 };
-  }, [fieldMap2, submit, client, triggerBody, applyValues, withBusy, setValue]);
-  const registerSheet = React13.useCallback((id, def) => {
-    sheetDefs.current.set(id, def);
-  }, []);
-  const api = {
-    status,
-    error,
-    definition,
-    mode,
-    readOnly,
-    values,
-    errors,
-    fields,
-    rootFields,
-    field: (id) => fieldMap2.get(id),
-    childrenOf,
-    setValue,
-    applyValues,
-    dirty,
-    submitting,
-    submitAttempted,
-    submitError,
-    submittedId,
-    validate,
-    submit,
-    reset,
-    runAction,
-    busy,
-    client,
-    registerSheet
-  };
-  apiRef.current = api;
-  return api;
-}
-var optionKey = (v) => String(v && typeof v === "object" ? v.select ?? v.value ?? v.view : v ?? "");
-var isFilled = (v) => v != null && v !== "" && !(Array.isArray(v) && !v.length);
-function useFieldOptions(form, field2, opts = {}) {
-  const { debounceMs = 250, loadOn = "focus", autofillExtraLabels = false } = opts;
-  const el2 = field2.element;
-  const cfg = React13.useMemo(() => field2.kind === "lookup" ? lookupConfigOf(el2) : null, [field2.kind, el2]);
-  const people = field2.kind === "user" && !!(el2.properties?.jsonData || el2.properties?.searchType === "GENERIC_FORM_AUTO_SEARCH");
-  const elements = form.definition?.elements ?? [];
-  const rules = React13.useMemo(() => optionFilterRules(elements, field2.id), [elements, field2.id]);
-  const dep = React13.useMemo(() => cfg ? lookupDependencyFilters(cfg, rules, elements, form.values) : { filters: [], satisfied: true }, [cfg, rules, elements, form.values]);
-  const depKey = JSON.stringify(dep.filters);
-  const maxCount = cfg ? cfg.maxResults : field2.kind === "user" ? maxResultsOf(el2) : field2.multiple ? Infinity : 1;
-  const single = maxCount === 1;
-  const [search, setSearch] = React13.useState("");
-  const [q, setQ] = React13.useState("");
-  React13.useEffect(() => {
-    const t = setTimeout(() => setQ(search), debounceMs);
-    return () => clearTimeout(t);
-  }, [search, debounceMs]);
-  const [remote, setRemote] = React13.useState([]);
-  const [loading, setLoading] = React13.useState(false);
-  const [error, setError] = React13.useState(null);
-  const [opened, setOpened] = React13.useState(loadOn === "mount");
-  const [nonce, setNonce] = React13.useState(0);
-  const lastFetch = React13.useRef(0);
-  const maxAge = React13.useRef(1e4);
-  const waitingFor = React13.useMemo(() => {
-    if (!cfg || dep.satisfied || cfg.operator !== "$and") return null;
-    const missing = rules.find((r) => !isFilled(form.values[r.elementId]));
-    const lbl = missing ? form.field(missing.elementId)?.label : cfg.dynamicFilters[0]?.DependencyFieldLabel;
-    return lbl ? `Select ${lbl} first` : "Fill the fields this depends on first";
-  }, [cfg, dep.satisfied, rules, form]);
-  const depDriven = !!cfg && rules.length > 0 && dep.filters.length > 0;
-  const active = opened || depDriven || q !== "";
-  React13.useEffect(() => {
-    if (!cfg && !people) return;
-    if (cfg && (waitingFor || cfg.loadOnDependency && !dep.filters.length && rules.length)) {
-      setRemote([]);
-      return;
-    }
-    if (!active) return;
-    let alive = true;
-    setLoading(true);
-    setError(null);
-    lastFetch.current = Date.now();
-    const p = cfg ? fetchLookupOptions(form.client, cfg, dep.filters, q, maxAge.current) : searchPeople(form.client, el2, q);
-    maxAge.current = 1e4;
-    p.then((o) => {
-      if (!alive) return;
-      setRemote(o);
-      if (cfg && rules.length && dep.filters.length && !q && o.length === 1) autoPickRef.current(o[0], depKey);
-    }).catch((e) => {
-      if (alive) setError(e?.message ?? "Couldn't load options");
-    }).finally(() => {
-      if (alive) setLoading(false);
-    });
-    return () => {
-      alive = false;
-    };
-  }, [cfg, people, depKey, q, waitingFor, form.client, active, nonce]);
-  const refresh = React13.useCallback(() => {
-    maxAge.current = 0;
-    setOpened(true);
-    setNonce((n) => n + 1);
-  }, []);
-  const onFocus = React13.useCallback(() => {
-    if (!cfg && !people) return;
-    if (!opened) {
-      setOpened(true);
-      return;
-    }
-    if (cfg && Date.now() - lastFetch.current > 2e3) {
-      maxAge.current = 2e3;
-      setNonce((n) => n + 1);
-    } else if (people && !remote.length) setNonce((n) => n + 1);
-  }, [cfg, people, opened, remote.length]);
-  const prevDepKey = React13.useRef(null);
-  React13.useEffect(() => {
-    if (!cfg || !rules.length) return;
-    if (prevDepKey.current === null) {
-      prevDepKey.current = depKey;
-      return;
-    }
-    if (prevDepKey.current === depKey) return;
-    prevDepKey.current = depKey;
-    if (form.readOnly) return;
-    if (isFilled(form.values[field2.id])) form.setValue(field2.id, single ? null : []);
-  }, [depKey]);
-  const staticFiltered = React13.useMemo(() => {
-    if (cfg || people) return remote;
-    const needle = search.trim().toLowerCase();
-    return needle ? field2.options.filter((o) => o.label.toLowerCase().includes(needle)) : field2.options;
-  }, [cfg, people, remote, field2.options, search]);
-  const pickedCache = React13.useRef(/* @__PURE__ */ new Map());
-  const current = field2.value;
-  const selected = React13.useMemo(() => {
-    const arr = current == null || current === "" ? [] : Array.isArray(current) ? current : [current];
-    const pool = [...staticFiltered, ...field2.options];
-    return arr.map((v) => {
-      const hit = pool.find((o) => optionKey(o.value) === optionKey(v)) ?? pickedCache.current.get(optionKey(v));
-      if (hit) return hit;
-      if (v && typeof v === "object") return { label: String(v.view ?? v.select ?? ""), value: String(v.select ?? v.view ?? ""), extra: v.extraLabels, raw: v };
-      return { label: String(v), value: v };
-    });
-  }, [current, staticFiltered, field2.options]);
-  const store = React13.useCallback((picked) => {
-    picked.forEach((o) => pickedCache.current.set(optionKey(o.value), o));
-    const t = field2.type;
-    if (field2.kind === "lookup") {
-      const rel = picked.map((o) => o.raw ?? { view: o.label, select: o.value, extraLabels: o.extra ?? [] });
-      form.setValue(field2.id, single ? rel[0] ?? null : rel.slice(0, maxCount));
-      if (autofillExtraLabels && cfg && picked.length === 1 && cfg.extraLabels.length) {
-        const fill2 = {};
-        cfg.extraLabels.forEach((label, i) => {
-          const target = (form.definition?.elements ?? []).find((e) => e.label === label && e.elementId !== field2.id);
-          const v = picked[0].extra?.[i];
-          if (target && v !== void 0) fill2[target.elementId] = v;
-        });
-        if (Object.keys(fill2).length) form.applyValues(fill2);
-      }
-      return;
-    }
-    if (field2.multiple) form.setValue(field2.id, picked.slice(0, maxCount).map((o) => o.value));
-    else form.setValue(field2.id, picked[0]?.value ?? (t === "CHECK_BOX" ? false : ""));
-  }, [field2, form, cfg, single, maxCount, autofillExtraLabels]);
-  const autoPickRef = React13.useRef(() => {
-  });
-  const lastAutoKey = React13.useRef(null);
-  autoPickRef.current = (o, key) => {
-    if (form.readOnly || lastAutoKey.current === key) return;
-    lastAutoKey.current = key;
-    if (isFilled(form.values[field2.id])) return;
-    store([o]);
-  };
-  const select = React13.useCallback((o) => store(o == null ? [] : Array.isArray(o) ? o : [o]), [store]);
-  const isSelected = React13.useCallback((o) => selected.some((s) => optionKey(s.value) === optionKey(o.value)), [selected]);
-  const atLimit = field2.multiple && selected.length >= maxCount;
-  const toggle = React13.useCallback((o) => {
-    const on = isSelected(o);
-    if (!on && field2.multiple && selected.length >= maxCount) return;
-    store(on ? selected.filter((s) => optionKey(s.value) !== optionKey(o.value)) : field2.multiple ? [...selected, o] : [o]);
-  }, [isSelected, selected, store, field2.multiple, maxCount]);
-  const addFreeTag = React13.useCallback((text) => {
-    const t = text.trim();
-    if (!t || field2.type !== "INPUT_TAG") return;
-    const o = { label: t, value: t, extra: [], raw: { view: t, select: t, extraLabels: [] } };
-    if (selected.some((s) => optionKey(s.value) === t)) return;
-    if (field2.multiple) {
-      if (selected.length < maxCount) store([...selected, o]);
-    } else store([o]);
-    setSearch("");
-  }, [field2.type, field2.multiple, selected, maxCount, store]);
-  return {
-    options: staticFiltered,
-    loading,
-    error,
-    search,
-    setSearch,
-    waitingFor,
-    selected,
-    select,
-    toggle,
-    isSelected,
-    onFocus,
-    refresh,
-    maxCount,
-    atLimit,
-    addFreeTag
-  };
-}
-var BLOCKED_FILE_EXTENSIONS = new Set("ade adp app application appref-ms asp aspx asx bas bat bgi cab cer chm cmd cnt com cpl crt csh der diagcab exe fxp gadget grp hlp hpj hta htc inf ins iso isp its jar jnlp js jse ksh lnk mad maf mag mam maq mar mas mat mau mav maw mcf mda mdb mde mdt mdw mdz msc msh msh1 msh2 mshxml msh1xml msh2xml msi msp mst msu ops osd pcd pif pl plg prf ps1 ps1xml ps2 ps2xml psc1 psc2 reg scr scf sln vbs vb vbe ws wsf wsc wsh z bz2 ace ppkg bak tmp ost pst pkg vhd vhdx lock lck cs csproj resx config resources pdb manifest dot wbk xlt xlm xla pot pps cdb mdn sh php mdf py ldb wps xlsb xlam xll xlw ppam".split(" "));
-function useFileField(form, field2, opts = {}) {
-  const stored = Array.isArray(field2.value) ? field2.value : [];
-  const [pending2, setPending] = React13.useState([]);
-  const [reject, setReject] = React13.useState(null);
-  const storedRef = React13.useRef(stored);
-  storedRef.current = stored;
-  const items = [
-    ...stored.map((r, i) => ({
-      key: `s${i}:${r.media_name ?? r.mediaName ?? r.name}`,
-      name: String(r.media_name ?? r.mediaName ?? r.name ?? "file"),
-      size: Number(r.media_size ?? r.mediaSize ?? r.size ?? 0),
-      type: String(r.media_type ?? r.mediaType ?? r.type ?? ""),
-      url: r.media ?? r.url,
-      uploading: false,
-      record: r
-    })),
-    ...pending2
-  ];
-  const max = field2.maxCount;
-  const add = React13.useCallback((list) => {
-    setReject(null);
-    const files = Array.from(list);
-    const room = max ? Math.max(0, max - storedRef.current.length - pending2.filter((p) => p.uploading).length) : files.length;
-    if (!room) {
-      setReject(`You can attach up to ${max} file${max === 1 ? "" : "s"}`);
-      return;
+    setSubmitAttempted(false);
+    setSubmitError(null);
+    setDirty(false);
+    if (definition) setStatus("ready");
+  }, [definition]);
+  const apiRef = React14.useRef(null);
+  const runAction = React14.useCallback(async (field2, choice) => {
+    const p = field2.element.properties ?? {};
+    const subType = String(field2.element.attributes?.subType ?? "");
+    const rawType = p.actionType ?? (subType && subType !== field2.element.type && subType !== field2.type ? subType : "") ?? p.subType;
+    const actionType = String(rawType || p.subType || "").toUpperCase();
+    const value = valuesRef.current[field2.id] ?? field2.value;
+    const ok = (fallback) => ({ ok: true, message: p.hideSuccessMessage ? void 0 : p.successMessage ?? fallback });
+    const fail = (fallback) => ({ ok: false, message: p.errorMessage ?? fallback });
+    const browser = typeof window !== "undefined" && typeof document !== "undefined";
+    if (field2.type === "CASCADED_ACTIONS" && isActionDropdown(field2.element)) {
+      const pick2 = choice ?? (typeof value === "string" ? value : "");
+      const target = (p.actionEleIds ?? []).map((id) => fieldMap2.get(String(id))).find((f) => f && f.label === pick2);
+      if (!target) return { ok: false, message: "No actions found to perform!" };
+      setValue(field2.id, pick2);
+      return runAction(target);
     }
-    files.slice(0, room).forEach((file) => {
-      const ext = file.name.includes(".") ? file.name.split(".").pop().toLowerCase() : "";
-      if (ext && BLOCKED_FILE_EXTENSIONS.has(ext)) {
-        setReject(`Cannot upload files with the extension .${ext}`);
-        return;
+    if (field2.type === "CASCADED_ACTIONS") {
+      for (const id of p.actionEleIds ?? []) {
+        const f = fieldMap2.get(String(id));
+        if (f) {
+          const r = await runAction(f);
+          if (!r.ok) return r;
+        }
       }
-      if (field2.maxSizeKB && file.size > field2.maxSizeKB * 1024) {
-        setReject(`${file.name} is larger than ${Math.round(field2.maxSizeKB / 1024 * 10) / 10 || field2.maxSizeKB} ${field2.maxSizeKB >= 1024 ? "MB" : "KB"}`);
-        return;
+      if (p.submit) await submit();
+      return { ok: true };
+    }
+    const handled = await argsRef.current.onAction?.(field2, apiRef.current);
+    if (handled) return handled;
+    const afterAutomation = (res) => {
+      const fd = formDataOf(res);
+      if (fd) applyValues(fd);
+      if (p.refreshForm && (submissionId || submittedId)) {
+        const delay = Number(p.refreshFormDelay) || 0;
+        setTimeout(() => setReloadTick((n) => n + 1), delay);
       }
-      const accept = field2.accept?.split(",").map((s) => s.trim().toLowerCase()).filter(Boolean);
-      if (accept?.length && !accept.some((a) => a.endsWith("/*") ? file.type.startsWith(a.slice(0, -1)) : a.startsWith(".") ? file.name.toLowerCase().endsWith(a) : file.type === a)) {
-        setReject(`${file.name} isn't an allowed file type`);
-        return;
+    };
+    const trig = p.triggerID ?? p.triggerId ?? p.TriggerID ?? p.actionID ?? p.automationId;
+    const isTrigger = actionType === "TRIGGER_AUTOMATION" || actionType === "TRIGGER" || field2.type === "TRIGGER_AUTOMATION" || field2.type === "INPUT_TRIGGER" || !actionType && !!trig;
+    if (isTrigger) {
+      const zeno = String(p.automationType ?? "").toUpperCase() === "ZENO";
+      if (zeno && !p.automationUuid) return fail("Automation ID missing from action");
+      if (!zeno && !trig) return fail("Automation ID missing from action");
+      return withBusy(field2.id, async () => {
+        try {
+          const body = triggerBody(valuesRef.current);
+          const res = zeno ? await invokeZeno(client, p.automationUuid, body) : await invokeTrigger(client, trig, body);
+          const failed = res?.comment?.type === "error" || res?.error || res?.code === 500 || res?.code === 400;
+          if (failed) {
+            const fd = formDataOf(res);
+            if (fd) applyValues(fd);
+            return fail(res?.comment?.message ?? res?.message ?? `${field2.label} failed`);
+          }
+          afterAutomation(res);
+          return ok(res?.comment?.message ?? res?.message);
+        } catch (e) {
+          return fail(e?.message ?? `${field2.label} failed`);
+        }
+      });
+    }
+    switch (actionType) {
+      case "":
+      case "OPEN_URL":
+      case "URL": {
+        const url = p.url ?? p.link ?? (typeof value === "string" && value ? value : field2.element.defaultValue);
+        if (url && typeof url === "string" && browser) window.open(url, "_blank", "noopener,noreferrer");
+        return url ? { ok: true } : fail("No link configured");
+      }
+      case "SUBMIT": {
+        const r = await submit();
+        return { ok: !!r, message: r ? p.successMessage : void 0 };
+      }
+      case "INVOKE_AGENT": {
+        if (!p.agentId) return fail("Agent ID missing from action");
+        return withBusy(field2.id, async () => {
+          try {
+            const body = buildTriggerBody(elements, valuesRef.current, { formId: definition?.uuid ?? formId, submissionId: submissionId ?? submittedId, byLabel: true });
+            const res = await invokeAgent(client, { content: { query: JSON.stringify(body), file_url: null } }, p.flowId, p.agentId);
+            if (!res) return fail(`${field2.label} failed`);
+            const fd = extractAgentFormData(res?.reply ?? res?.data?.reply ?? res);
+            if (fd) applyValues(fd);
+            return p.successMessage ? ok() : { ok: true };
+          } catch (e) {
+            return fail(e?.message ?? `${field2.label} failed`);
+          }
+        });
+      }
+      case "DOWNLOAD_FILE": {
+        const file = typeof value === "string" && value || p.url || field2.element.defaultValue;
+        if (!file) return fail("File URL missing from action");
+        if (browser) {
+          const a = document.createElement("a");
+          a.href = String(file);
+          a.download = p.fileName ?? "";
+          a.target = "_blank";
+          a.rel = "noopener";
+          a.click();
+        }
+        return { ok: true };
+      }
+      case "PRINT_PREVIEW": {
+        const file = typeof value === "string" && value || p.url || field2.element.defaultValue;
+        if (!file) return fail("File URL missing from action");
+        if (!browser) return fail("Printing needs a browser");
+        return withBusy(field2.id, async () => {
+          try {
+            const blob = await (await fetch(String(file))).blob();
+            const url = URL.createObjectURL(new Blob([blob], { type: "application/pdf" }));
+            const frame = document.createElement("iframe");
+            frame.style.display = "none";
+            frame.src = url;
+            document.body.appendChild(frame);
+            frame.onload = () => frame.contentWindow?.print();
+            return { ok: true };
+          } catch {
+            return fail("Failed to load file for printing");
+          }
+        });
+      }
+      case "UPLOAD_FILE": {
+        if (!browser) return fail("Uploading needs a browser");
+        const file = await new Promise((resolve) => {
+          const input = document.createElement("input");
+          input.type = "file";
+          input.onchange = () => resolve(input.files?.[0] ?? null);
+          input.click();
+        });
+        if (!file) return fail("File upload failed");
+        const ext = file.name.includes(".") ? file.name.split(".").pop().toLowerCase() : "";
+        if (ext && BLOCKED_FILE_EXTENSIONS.has(ext)) return { ok: false, message: `Cannot upload files with the extension .${ext}` };
+        const maxKB = Number(field2.element.attributes?.allowedFileMaxSize) || 0;
+        if (maxKB && file.size / 1024 > maxKB) return { ok: false, message: `File size exceeds maximum limit ${maxKB} KB.` };
+        return withBusy(field2.id, async () => {
+          try {
+            const rec = await uploadFile(client, { ...field2.element, type: p.cardID || p.cardId ? "UPLOAD_FILE_IMAGE" : field2.element.type }, file, argsRef.current.zappId);
+            setValue(field2.id, rec.media);
+            return ok("File successfully uploaded");
+          } catch (e) {
+            return fail(e?.message ?? "File upload failed");
+          }
+        });
+      }
+      case "CREATE_SUBMISSION":
+      case "EDIT_SUBMISSION":
+      case "SAVE_SUBMISSION":
+      case "OPEN_TASK":
+      case "OPEN_PROJECT":
+      case "AGENT":
+      case "FLOW":
+        return { ok: false, message: `"${field2.label}" (${actionType}) opens other screens \u2014 pass onAction to <ZvolvForm> and use openFormRequest(field, form)` };
+      default: {
+        setValue(field2.id, true);
+        const r = await submit();
+        return { ok: !!r, message: r ? p.successMessage : void 0 };
       }
-      const key = `p${Date.now()}${Math.random()}`;
-      setPending((p) => [...p, { key, name: file.name, size: file.size, type: file.type, uploading: true }]);
-      uploadFile(form.client, field2.element, file, opts.zappId).then((rec) => {
-        setPending((p) => p.filter((x) => x.key !== key));
-        const next = [...storedRef.current, rec];
-        storedRef.current = next;
-        form.setValue(field2.id, next);
-      }).catch((e) => setPending((p) => p.map((x) => x.key === key ? { ...x, uploading: false, error: e?.message ?? "Upload failed" } : x)));
-    });
-    if (files.length > room) setReject(`Only ${room} more file${room === 1 ? "" : "s"} can be attached`);
-  }, [form, field2, max, pending2, opts.zappId]);
-  const remove = React13.useCallback((key) => {
-    if (key.startsWith("p")) {
-      setPending((p) => p.filter((x) => x.key !== key));
-      return;
     }
-    const idx = items.findIndex((i) => i.key === key);
-    if (idx < 0) return;
-    const next = storedRef.current.filter((_2, i) => i !== idx);
-    form.setValue(field2.id, next.length ? next : []);
-  }, [items, form, field2.id]);
-  return { items, uploading: pending2.some((p) => p.uploading), add, remove, canAdd: !field2.disabled && (!max || stored.length < max), rejectReason: reject };
-}
-function sheetAllows(p, action) {
-  const specific = action === "ADD" ? p?.allowedAddActions : p?.allowedDeleteActions;
-  const list = Array.isArray(specific) && specific.length ? specific : p?.allowedActions;
-  if (!Array.isArray(list) || !list.length) return true;
-  return list.map((x) => String(x).toUpperCase()).includes(action);
+  }, [fieldMap2, submit, client, triggerBody, applyValues, withBusy, setValue, elements, definition, formId, submissionId, submittedId]);
+  const reload = React14.useCallback(() => setReloadTick((n) => n + 1), []);
+  const [sheetVersion, setSheetVersion] = React14.useState(0);
+  const registerSheet = React14.useCallback((id, def) => {
+    if (sheetDefs.current.get(id) === def) return;
+    sheetDefs.current.set(id, def);
+    setSheetVersion((n) => n + 1);
+  }, []);
+  const sheetDefinition = React14.useCallback((id) => sheetDefs.current.get(id), []);
+  const api = {
+    status,
+    error,
+    definition,
+    mode,
+    readOnly,
+    values,
+    errors,
+    fields,
+    rootFields,
+    field: (id) => fieldMap2.get(id),
+    childrenOf,
+    setValue,
+    applyValues,
+    dirty,
+    submitting,
+    submitAttempted,
+    submitError,
+    submittedId,
+    validate,
+    submit,
+    reset,
+    runAction,
+    reload,
+    busy,
+    client,
+    registerSheet,
+    sheetDefinition,
+    sheetVersion
+  };
+  apiRef.current = api;
+  return api;
 }
-function useSheetField(form, field2) {
-  const childId = String(field2.element.properties?.formID ?? field2.element.properties?.FormID ?? field2.element.properties?.nestedFormId ?? field2.element.properties?.dataSource?.FormID ?? "");
-  const [child, setChild] = React13.useState(null);
-  const [loading, setLoading] = React13.useState(!!childId);
-  const [error, setError] = React13.useState(childId ? null : "No child form configured");
-  React13.useEffect(() => {
-    if (!childId) return;
-    let alive = true;
-    setLoading(true);
-    fetchForm(form.client, childId).then(async (def) => {
-      if (!alive) return;
-      setChild(def);
-      form.registerSheet(field2.id, def);
-      const raw2 = Array.isArray(field2.value) ? field2.value : [];
-      const ids = raw2.filter((r) => typeof r === "string" || typeof r === "number").map(String);
-      if (ids.length) {
-        const rows2 = await fetchRows(form.client, childId, ids);
-        if (alive) form.applyValues({ [field2.id]: rows2 });
-      }
-    }).catch((e) => alive && setError(e?.message ?? "Couldn't load the table")).finally(() => alive && setLoading(false));
-    return () => {
-      alive = false;
-    };
-  }, [childId, form.client]);
-  const columns = React13.useMemo(() => (child?.elements ?? []).filter((e) => !e.hidden && !["COLLAPSE_SECTION", "CONTAINER", "GROUP_VIEW", "TEXT_VIEW", "ACTION_BUTTON"].includes(resolveFieldType(e))).map((e) => ({
-    id: e.elementId,
-    label: e.label,
-    type: resolveFieldType(e),
-    required: e.required,
-    element: e,
-    options: (Array.isArray(e.properties?.options) ? e.properties.options : []).map((o) => typeof o === "object" ? { label: String(o.view ?? o.label ?? o.select), value: o.select ?? o.value } : { label: String(o), value: o })
-  })), [child]);
-  const rows = (Array.isArray(field2.value) ? field2.value : []).filter((r) => r && typeof r === "object");
+function openFormRequest(field2, form) {
   const p = field2.element.properties ?? {};
-  const maxRows = Number(p.maxRows) > 0 ? Number(p.maxRows) : void 0;
-  const [limitMessage, setLimitMessage] = React13.useState(null);
-  const addAllowed = !field2.disabled && sheetAllows(p, "ADD");
-  const canDelete = !field2.disabled && sheetAllows(p, "DELETE");
-  const addRow = React13.useCallback((vals) => {
-    if (!addAllowed) return;
-    if (maxRows && rows.length >= maxRows) {
-      setLimitMessage(`Maximum number of rows reached (${maxRows})`);
-      return;
-    }
-    setLimitMessage(null);
-    const blank = child ? buildInitialValues(child.elements, { defaults: vals }) : { ...vals ?? {} };
-    form.setValue(field2.id, [...rows, { ...blank, _rowKey: `r${Date.now()}${Math.random()}` }]);
-  }, [child, rows, form, field2.id, addAllowed, maxRows]);
-  const updateRow = React13.useCallback((i, col, v) => {
-    form.setValue(field2.id, rows.map((r, j) => j === i ? { ...r, [col]: v, _dirty: true } : r));
-  }, [rows, form, field2.id]);
-  const removeRow = React13.useCallback((i) => {
-    if (!canDelete) return;
-    setLimitMessage(null);
-    form.setValue(field2.id, rows.filter((_2, j) => j !== i));
-  }, [rows, form, field2.id, canDelete]);
-  const rowErrors = React13.useMemo(() => {
-    const out = {};
-    if (!form.submitAttempted) return out;
-    rows.forEach((r, i) => {
-      if (!sheetRowNeedsCheck(r)) return;
-      columns.forEach((c) => {
-        if (!sheetCellChecked(c.element)) return;
-        const e = validateField(c.element, r[c.id]);
-        if (e) out[`${i}:${c.id}`] = e;
+  const t = String(p.actionType ?? p.subType ?? "").toUpperCase();
+  const value = form.values[field2.id] ?? field2.value;
+  const has2 = value != null && value !== "" && value !== true;
+  const formId = p.formId ?? p.formID;
+  switch (t) {
+    case "CREATE_SUBMISSION":
+      return formId ? { actionType: t, formId: String(formId), mode: "NEW" } : null;
+    case "EDIT_SUBMISSION":
+    case "OPEN_TASK":
+      return has2 ? { actionType: t, submissionId: String(value), mode: "EDIT" } : null;
+    case "OPEN_PROJECT":
+      return has2 ? { actionType: t, projectId: String(value), mode: "EDIT" } : null;
+    case "SAVE_SUBMISSION": {
+      if (!formId) return null;
+      const defaults = {};
+      (Array.isArray(p.inputMap) ? p.inputMap : []).forEach((m) => {
+        if (m?.sourceElementId && m?.destinationElementId && form.values[m.sourceElementId] !== void 0) defaults[m.destinationElementId] = form.values[m.sourceElementId];
       });
-    });
-    return out;
-  }, [rows, columns, form.submitAttempted]);
+      return { actionType: t, formId: String(formId), submissionId: has2 ? String(value) : void 0, mode: has2 ? "EDIT" : "NEW", defaultValues: Object.keys(defaults).length ? defaults : void 0 };
+    }
+    default:
+      return null;
+  }
+}
+var CORRECT = ["IND", "NR", "CHECK"];
+var isCorrect = (l) => CORRECT.includes(String(l).toUpperCase());
+var fmt = (s) => [Math.floor(s / 3600), Math.floor(s % 3600 / 60), s % 60].map((v) => String(v).padStart(2, "0")).join(":");
+var toButtons = (rb) => Object.entries(rb ?? {}).map(([label, c]) => ({
+  label,
+  icon: c?.icon,
+  color: c?.color,
+  hideLabel: !!c?.hideLabel,
+  disabled: !!c?.isDisabled,
+  prompts: Object.entries(c?.PromptButtons ?? {}).map(([pl, pc]) => ({ label: pl, icon: pc?.icon, color: pc?.color, hideLabel: !!pc?.hideLabel }))
+}));
+function useTrialField(form, field2) {
+  const t = field2.type;
+  const type = t === "INPUT_TIME_SAMPLING" ? "time" : t === "INPUT_TASK_ANALYSIS" ? "task" : "percent";
+  const props = field2.element.properties ?? {};
+  const value = field2.value && typeof field2.value === "object" ? field2.value : null;
+  const conf = React14.useMemo(() => ({ ...props, ...value?.conf ?? {} }), [props, value?.conf]);
+  const disabled = field2.disabled || form.readOnly;
+  const set = (v) => form.setValue(field2.id, v);
+  const [active, setActive] = React14.useState();
+  const maxTrials = Number(conf.maximumNumberOfTrials ?? (type === "task" ? 5 : 10));
+  const pcResp = type === "percent" && Array.isArray(value?.buttonResp) ? value.buttonResp : [];
+  const pcTrial = type === "percent" ? Number(conf.currentTrial ?? pcResp.length) || pcResp.length : 0;
+  const linkedTimer = () => {
+    const v = conf.LinkedTimerField ? form.values[conf.LinkedTimerField] : null;
+    return v?.lastStatus?.timer ?? (typeof v === "number" ? v : 0);
+  };
+  const timeLimit = Number(conf.timeLimit ?? 300);
+  const interval = Number(conf.timeInterval ?? 30) || 30;
+  const [timer, setTimer] = React14.useState(Number(value?.lastStatus?.timer ?? 0));
+  const [running, setRunning] = React14.useState(false);
+  const timerRef = React14.useRef(timer);
+  timerRef.current = timer;
+  React14.useEffect(() => {
+    if (!running) return;
+    const id = setInterval(() => setTimer((p) => {
+      const n = p + 1;
+      timerRef.current = n;
+      if (n >= timeLimit) setRunning(false);
+      return n;
+    }), 1e3);
+    return () => clearInterval(id);
+  }, [running, timeLimit]);
+  const tsResp = type === "time" && Array.isArray(value?.buttonResp) ? value.buttonResp : [];
+  const bound = (s) => {
+    const i = Math.floor(s / interval);
+    return `${i * interval}-${(i + 1) * interval}`;
+  };
+  const tsEmit = (resp, at) => set({
+    conf: value?.conf ?? { timeLimit, timeInterval: interval, ResponseButtons: conf.ResponseButtons ?? {} },
+    buttonResp: resp,
+    lastStatus: { timer: at, intervalCount: Math.floor(at / interval), formattedTimer: fmt(at), currentIntervalBound: bound(at) }
+  });
+  const steps = React14.useMemo(() => Object.keys(conf.steps ?? {}), [conf.steps]);
+  const chain = conf.type === "backward" ? "backward" : conf.type === "whole" ? "whole" : "forward";
+  const taResp = type === "task" && value?.buttonResp && typeof value.buttonResp === "object" && !Array.isArray(value.buttonResp) ? value.buttonResp : {};
+  const taTrial = type === "task" ? parseInt(String(value?.currentStatus?.currentTrial ?? "0").replace("Trial ", ""), 10) || 0 : 0;
+  const firstStep = chain === "backward" ? Math.max(0, steps.length - 1) : 0;
+  const taStep = type === "task" ? Number(value?.currentStatus?.currentStep ?? firstStep) : 0;
+  const stepName = steps[taStep] ?? "";
+  const taEmit = (resp, trial, step) => set({
+    conf: { ...value?.conf ?? { type: chain, maximumNumberOfTrials: maxTrials, steps: conf.steps ?? {} }, currentTrial: trial },
+    buttonResp: resp,
+    currentStatus: { currentStep: step, currentTrial: `Trial ${trial}` }
+  });
+  const currentTrial = type === "percent" ? pcTrial : type === "task" ? taTrial : tsResp.length;
+  const complete = type === "time" ? timer >= timeLimit : currentTrial >= maxTrials;
+  const rb = type === "task" ? conf.steps?.[stepName]?.ResponseButtons : conf.ResponseButtons;
+  const buttons = React14.useMemo(() => toButtons(rb), [rb]);
+  const record = React14.useCallback((response, promptLabel) => {
+    if (disabled) return;
+    if (type === "percent") {
+      if (pcTrial >= maxTrials) return;
+      const entry = { sessionTimerValue: linkedTimer(), responseButtonPressed: response, ...promptLabel ? { promptButtonPressed: promptLabel } : {} };
+      const next = pcTrial + 1;
+      set({ conf: { ...value?.conf ?? { maximumNumberOfTrials: maxTrials, ResponseButtons: conf.ResponseButtons ?? {}, LinkedTimerField: conf.LinkedTimerField }, currentTrial: next }, buttonResp: [...pcResp, entry] });
+    } else if (type === "time") {
+      const at = timerRef.current;
+      tsEmit([...tsResp, { sessionTimerValue: at, responseButtonPressed: response, ...promptLabel ? { promptButtonPressed: promptLabel } : {}, interval: Math.floor(at / interval), intervalBound: bound(at) }], at);
+    } else {
+      if (taTrial >= maxTrials || !steps.length) return;
+      const key = `Trial ${taTrial}`;
+      const resp = { ...taResp, [key]: [...taResp[key] ?? [], { responseButtonPressed: response, ...promptLabel ? { promptButtonPressed: promptLabel } : {}, stepName }] };
+      let step = taStep, trial = taTrial;
+      if (chain === "backward") {
+        step -= 1;
+        if (step < 0) {
+          step = steps.length - 1;
+          trial += 1;
+        }
+      } else {
+        step += 1;
+        if (step >= steps.length) {
+          step = 0;
+          trial += 1;
+        }
+      }
+      taEmit(resp, trial, step);
+    }
+    setActive(void 0);
+  }, [disabled, type, pcTrial, maxTrials, pcResp, tsResp, taResp, taTrial, taStep, steps, stepName, chain, value, conf]);
+  const respond = React14.useCallback((label) => {
+    const b = buttons.find((x) => x.label === label);
+    if (!b || b.disabled) return;
+    if (b.prompts.length) setActive(label);
+    else record(label);
+  }, [buttons, record]);
+  const prompt = React14.useCallback((label) => {
+    if (active) record(active, label);
+  }, [active, record]);
+  const prev = React14.useCallback(() => {
+    if (disabled) return;
+    if (type === "percent" && pcTrial > 0) {
+      set({ conf: { ...value?.conf ?? { maximumNumberOfTrials: maxTrials, ResponseButtons: conf.ResponseButtons ?? {} }, currentTrial: pcTrial - 1 }, buttonResp: pcResp.slice(0, -1) });
+    } else if (type === "task" && taTrial > 0) {
+      const resp = { ...taResp };
+      delete resp[`Trial ${taTrial}`];
+      taEmit(resp, taTrial - 1, firstStep);
+    }
+  }, [disabled, type, pcTrial, pcResp, taTrial, taResp, firstStep, value, conf, maxTrials]);
+  const reset = React14.useCallback(() => {
+    if (type !== "time" || disabled) return;
+    setTimer(0);
+    setRunning(false);
+    setActive(void 0);
+    tsEmit([], 0);
+  }, [type, disabled, value, conf]);
+  const allResp = type === "task" ? Object.entries(taResp).flatMap(([trial, arr]) => (Array.isArray(arr) ? arr : []).map((r) => ({ r, trial }))) : (type === "time" ? tsResp : pcResp).map((r) => ({ r }));
+  const log = allResp.map(({ r, trial }, i) => ({
+    label: type === "task" ? `${trial} / ${r.stepName ?? "?"}: ${r.responseButtonPressed}` : type === "percent" ? `Trial ${i + 1}: ${r.responseButtonPressed}` : String(r.responseButtonPressed),
+    correct: isCorrect(r.responseButtonPressed),
+    detail: [r.promptButtonPressed ? `\u2192 ${r.promptButtonPressed}` : "", type === "time" ? `@ ${fmt(Number(r.sessionTimerValue) || 0)}` : ""].filter(Boolean).join(" ") || void 0
+  }));
+  const percentCorrect = log.length ? Math.round(log.filter((l) => l.correct).length / log.length * 100) : 0;
   return {
-    loading,
-    error,
-    columns,
-    rows,
-    addRow,
-    updateRow,
-    removeRow,
-    rowErrors,
-    childForm: child,
-    canAdd: addAllowed && (!maxRows || rows.length < maxRows),
-    canDelete,
-    maxRows,
-    limitMessage,
-    display: (c, v) => formatFieldValue(c.element, v)
+    type,
+    buttons,
+    activeResponse: active,
+    prompts: buttons.find((b) => b.label === active)?.prompts ?? [],
+    respond,
+    prompt,
+    cancelPrompt: () => setActive(void 0),
+    prev,
+    currentTrial,
+    maxTrials,
+    complete,
+    percentCorrect,
+    log,
+    disabled,
+    timer,
+    formattedTimer: fmt(timer),
+    running,
+    start: () => {
+      if (!disabled && timer < timeLimit) setRunning(true);
+    },
+    pause: () => setRunning(false),
+    reset,
+    interval,
+    intervalCount: Math.floor(timer / interval),
+    timeLimit,
+    steps,
+    currentStep: taStep,
+    stepName,
+    chain
   };
 }
-var FormKitSlot = React13__default.default.createContext(null);
+var FormKitSlot = React14__default.default.createContext(null);
 function useKit(local) {
-  const ctx = React13__default.default.useContext(FormKitSlot);
-  return React13__default.default.useMemo(() => ({ ...ctx ?? {}, ...local ?? {} }), [ctx, local]);
+  const ctx = React14__default.default.useContext(FormKitSlot);
+  return React14__default.default.useMemo(() => ({ ...ctx ?? {}, ...local ?? {} }), [ctx, local]);
 }
 var FormFields = ({ form, fields, kit: local }) => {
   const kit = useKit(local);
@@ -7342,6 +8254,33 @@ var DefaultSheet = ({ field: field2, form }) => {
     s.limitMessage && /* @__PURE__ */ jsxRuntime.jsx("div", { role: "alert", children: s.limitMessage })
   ] });
 };
+var DefaultTrials = ({ field: field2, form }) => {
+  const t = useTrialField(form, field2);
+  return /* @__PURE__ */ jsxRuntime.jsxs("div", { children: [
+    /* @__PURE__ */ jsxRuntime.jsxs("div", { children: [
+      t.type === "time" ? `${t.formattedTimer} \xB7 interval ${t.intervalCount + 1}` : `Trial ${t.currentTrial} / ${t.maxTrials}`,
+      t.type === "task" && t.stepName ? ` \xB7 ${t.stepName}` : "",
+      " \xB7 ",
+      t.percentCorrect,
+      "% correct",
+      t.complete ? " \xB7 complete" : ""
+    ] }),
+    t.type === "time" && /* @__PURE__ */ jsxRuntime.jsxs("span", { children: [
+      /* @__PURE__ */ jsxRuntime.jsx("button", { type: "button", disabled: t.disabled || t.complete, onClick: t.running ? t.pause : t.start, children: t.running ? "Pause" : "Start" }),
+      " ",
+      /* @__PURE__ */ jsxRuntime.jsx("button", { type: "button", disabled: t.disabled, onClick: t.reset, children: "Reset" })
+    ] }),
+    t.type !== "time" && /* @__PURE__ */ jsxRuntime.jsx("button", { type: "button", disabled: t.disabled || t.currentTrial <= 0, onClick: t.prev, children: "Undo" }),
+    /* @__PURE__ */ jsxRuntime.jsxs("div", { children: [
+      (t.activeResponse ? t.prompts : t.buttons).map((b) => /* @__PURE__ */ jsxRuntime.jsx("button", { type: "button", disabled: t.disabled || t.complete, onClick: () => t.activeResponse ? t.prompt(b.label) : t.respond(b.label), children: b.label }, b.label)),
+      t.activeResponse && /* @__PURE__ */ jsxRuntime.jsx("button", { type: "button", onClick: t.cancelPrompt, children: "Cancel" })
+    ] }),
+    /* @__PURE__ */ jsxRuntime.jsx("ol", { children: t.log.map((l, i) => /* @__PURE__ */ jsxRuntime.jsxs("li", { style: { color: l.correct ? "#2e7d32" : "#c62828" }, children: [
+      l.label,
+      l.detail ? ` ${l.detail}` : ""
+    ] }, i)) })
+  ] });
+};
 var DefaultField = ({ field: field2, form }) => {
   const f = field2;
   const lbl = !f.hideLabel && f.kind !== "checkbox" && f.kind !== "action" && f.kind !== "display" ? /* @__PURE__ */ jsxRuntime.jsxs("label", { htmlFor: f.id, style: { display: "block", fontWeight: 600, marginBottom: 4 }, children: [
@@ -7370,7 +8309,20 @@ var DefaultField = ({ field: field2, form }) => {
     case "display":
       return /* @__PURE__ */ jsxRuntime.jsx("div", { dangerouslySetInnerHTML: { __html: f.html ?? "" } });
     case "action":
+      if (f.variant === "dropdown") {
+        return /* @__PURE__ */ jsxRuntime.jsxs("label", { children: [
+          f.label,
+          " ",
+          /* @__PURE__ */ jsxRuntime.jsxs("select", { disabled: f.disabled, value: typeof f.value === "string" ? f.value : "", onChange: (e) => e.target.value && void form.runAction(f, e.target.value), children: [
+            /* @__PURE__ */ jsxRuntime.jsx("option", { value: "", children: f.placeholder ?? "Choose an action" }),
+            f.options.map((o) => /* @__PURE__ */ jsxRuntime.jsx("option", { value: String(o.value), children: o.label }, String(o.value)))
+          ] })
+        ] });
+      }
       return /* @__PURE__ */ jsxRuntime.jsx("button", { type: "button", disabled: f.disabled || form.busy.has(f.id), onClick: () => void form.runAction(f), children: f.label });
+    case "trials":
+      control = /* @__PURE__ */ jsxRuntime.jsx(DefaultTrials, { field: f, form });
+      break;
     case "checkbox":
       control = /* @__PURE__ */ jsxRuntime.jsxs("label", { children: [
         /* @__PURE__ */ jsxRuntime.jsx("input", { id: f.id, type: "checkbox", role: f.variant === "switch" ? "switch" : void 0, disabled: f.disabled, checked: f.value === true, onChange: (e) => f.setValue(e.target.checked), onBlur: f.onBlur }),
@@ -7452,12 +8404,12 @@ var TabWidget = ({
   render
 }) => {
   const t = useTokens();
-  const config = React13.useMemo(
+  const config = React14.useMemo(
     () => resolveWidgetDefaults(t, "TAB", parseConfig(configurations)),
     [t, configurations]
   );
   const chrome = resolveChromeConfig(config);
-  const tabs = React13.useMemo(() => {
+  const tabs = React14.useMemo(() => {
     const declared = config?.tabs ?? config?.childWidget ?? [];
     return declared.map((tab, i) => ({
       key: String(tab?.key ?? tab?.id ?? i),
@@ -7465,7 +8417,7 @@ var TabWidget = ({
       widget: tab?.widget ?? tab
     }));
   }, [config]);
-  const [activeKey, setActiveKey] = React13.useState("");
+  const [activeKey, setActiveKey] = React14.useState("");
   const current = activeKey || tabs[0]?.key || "";
   const args = { tabs, activeKey: current, setActiveKey, tokens: t, config };
   return /* @__PURE__ */ jsxRuntime.jsx(
@@ -7525,7 +8477,7 @@ var FormWidget = ({
   onSubmitted
 }) => {
   const t = useTokens();
-  const config = React13.useMemo(
+  const config = React14.useMemo(
     () => resolveWidgetDefaults(t, "FORM", parseConfig(configurations)),
     [t, configurations]
   );
@@ -7566,12 +8518,12 @@ var FilterPanelWidget = ({
   render
 }) => {
   const t = useTokens();
-  const config = React13.useMemo(
+  const config = React14.useMemo(
     () => resolveWidgetDefaults(t, "FILTER_PANEL", parseConfig(configurations)),
     [t, configurations]
   );
   const chrome = resolveChromeConfig(config);
-  const controls = React13.useMemo(() => {
+  const controls = React14.useMemo(() => {
     const declared = config?.filters ?? config?.controls ?? [];
     return declared.map((f, i) => ({
       key: String(f?.key ?? f?.field ?? f?.masterfield ?? i),
@@ -7580,7 +8532,7 @@ var FilterPanelWidget = ({
       options: f?.options
     }));
   }, [config]);
-  const [draft, setDraft] = React13.useState({});
+  const [draft, setDraft] = React14.useState({});
   const values = { ...draft, ...value || {} };
   const setValue = (key, v) => {
     const next = { ...values, [key]: v };
@@ -7645,7 +8597,7 @@ var ZaiChatWidget = ({
   render
 }) => {
   const t = useTokens();
-  const config = React13.useMemo(
+  const config = React14.useMemo(
     () => resolveWidgetDefaults(t, "ZAI_CHAT", parseConfig(configurations)),
     [t, configurations]
   );
@@ -7876,7 +8828,7 @@ function buildDashFilters(values = [], dateRange, operator = "AND") {
 }
 function dateRangeFor(token) {
   const f = (d) => d.format("YYYY-MM-DD");
-  const now = dayjs8__default.default();
+  const now = dayjs4__default.default();
   switch (token) {
     case "TODAY":
       return { start: f(now), end: f(now) };
@@ -7948,6 +8900,232 @@ function buildDashboardTree(elements, isAdmin = false) {
   });
   return list.filter((d) => !childIds.has(String(d.ReportID)) && visible(d)).sort(seq).map(node);
 }
+var text = (v) => {
+  if (v === null || v === void 0 || v === "") return "";
+  if (Array.isArray(v)) return v.map(text).filter(Boolean).join(", ");
+  if (typeof v === "object") return text(v.view ?? v.select ?? v.label ?? v.value ?? JSON.stringify(v));
+  return String(v);
+};
+var effectOf = (action) => action.startsWith("SHOW") ? "show" : action.startsWith("HIDE") ? "hide" : action.startsWith("MARK_MANDATORY") ? "required" : action.startsWith("MARK_NON") ? "optional" : action === "EDITABLE" ? "editable" : action === "NON_EDITABLE" ? "read-only" : null;
+function expectedOf(dep, labelOf) {
+  const conds = dep.conditions ?? dep.Conditions ?? [];
+  if (conds.length) {
+    const op = String(dep.conditionOperator ?? dep.operator ?? "AND").toUpperCase();
+    return conds.map((c) => `${labelOf(c.elementId ?? c.dependencyElementId)} ${c.operator ?? c.conditionOperator ?? "equals"} ${text(c.value ?? c.conditionValue)}`).join(` ${op} `);
+  }
+  if (Array.isArray(dep.value)) return `exactly [${dep.value.map(String).join(", ")}]`;
+  return `= ${text(dep.value) || "(empty)"}`;
+}
+function checksOf(el2, required) {
+  const t = resolveFieldType(el2);
+  const p = el2.properties ?? {};
+  const out = [];
+  if (required) out.push("required");
+  if (t === "INPUT_EMAIL") out.push("email");
+  if (t === "INPUT_URL") out.push("url");
+  if (t === "INPUT_PHONE") out.push("phone");
+  if (t === "INPUT_PERCENT") out.push("0\u2013100");
+  const min = p.minVal ?? p.min, max = p.maxVal ?? p.max;
+  if (min !== void 0 && min !== null && min !== "") out.push(`min ${min}`);
+  if (max !== void 0 && max !== null && max !== "") out.push(`max ${max}`);
+  const len = p.maxLength ?? (t === "RICH_TEXT_EDITOR" ? p.max ?? el2.attributes?.charactersCount : void 0);
+  if (len) out.push(`\u2264 ${len} chars`);
+  if (p.minimumNumberOfTrials) out.push(`\u2265 ${p.minimumNumberOfTrials} trials`);
+  (el2.validations ?? []).forEach((v) => {
+    const k = String(v?.type ?? v?.validationType ?? "").toLowerCase();
+    if (k === "regex") out.push("pattern");
+    else if (k === "expression") out.push("expression");
+    else if (k) out.push(`${k} (server)`);
+  });
+  return out;
+}
+var sameNumber = (a, b) => {
+  if ((a === null || a === void 0 || a === "") && (b === null || b === void 0 || b === "")) return true;
+  const na = Number(a), nb = Number(b);
+  return !Number.isNaN(na) && !Number.isNaN(nb) ? Math.abs(na - nb) < 1e-6 : String(a) === String(b);
+};
+function formulaRows(elements, values, scope, extra = {}) {
+  const labels = elements.map((e) => e.label).filter(Boolean);
+  const idOf2 = new Map(elements.map((e) => [e.label, e.elementId]));
+  return elements.filter((e) => resolveFieldType(e) === "INPUT_FORMULA" && e.properties?.formula).map((e) => {
+    const formula = String(e.properties.formula);
+    const refs = formulaLabels(formula, labels);
+    const inputs = refs.map((l) => ({ label: l, value: values[idOf2.get(l) ?? l] ?? null }));
+    const expected = extra.expectedRow ? extra.expectedRow[e.elementId] : refs.length && inputs.every((i) => i.value === null || i.value === "") ? null : evaluateFormula(formula, (l) => values[idOf2.get(l) ?? l], labels);
+    const current = values[e.elementId] ?? null;
+    return {
+      fieldId: e.elementId,
+      label: e.label,
+      scope,
+      sheetLabel: extra.sheetLabel,
+      row: extra.row,
+      formula,
+      serverFormula: toBraceFormula(formula, labels),
+      serverSafe: isServerSafeFormula(formula, labels),
+      inputs,
+      expected,
+      current,
+      inSync: sameNumber(expected, current)
+    };
+  });
+}
+function inspectForm(form) {
+  const def = form.definition;
+  if (!def) {
+    return {
+      rules: [],
+      filters: [],
+      validation: [],
+      formulas: [],
+      defaults: [],
+      payload: null,
+      summary: { rules: 0, matched: 0, filters: 0, activeFilters: 0, errors: 0, formulas: 0, formulaIssues: 0 }
+    };
+  }
+  const elements = def.elements;
+  const values = form.values;
+  const byId = new Map(elements.map((e) => [e.elementId, e]));
+  const labelOf = (id) => byId.get(String(id))?.label ?? String(id ?? "");
+  const rules = [];
+  elements.forEach((el2) => {
+    const origin = el2.properties?.triage ? "triage" : "dependencies";
+    rulesOf(el2).forEach((dep) => {
+      const action = String(dep.dependencyType ?? dep.type ?? "");
+      const effect = effectOf(action);
+      const target = String(dep.elementId ?? dep.targetElementId ?? "");
+      if (!effect || !target) return;
+      rules.push({
+        sourceId: el2.elementId,
+        sourceLabel: el2.label,
+        sourceValue: text(values[el2.elementId]) || "(empty)",
+        action,
+        effect,
+        targetId: target,
+        targetLabel: labelOf(target),
+        expected: expectedOf(dep, labelOf),
+        matched: ruleMatches(el2, dep, values),
+        origin
+      });
+    });
+  });
+  const filters2 = [];
+  elements.forEach((el2) => {
+    const cfg = lookupConfigOf(el2);
+    if (!cfg) return;
+    const base2 = { targetId: el2.elementId, targetLabel: el2.label, sourceForm: cfg.formId };
+    optionFilterRules(elements, el2.elementId).forEach((r) => {
+      const v = text(values[r.elementId]);
+      filters2.push({ ...base2, kind: "dependent", masterField: r.masterField, sourceLabel: labelOf(r.elementId), sourceValue: v || "(empty)", active: !!v });
+    });
+    cfg.dynamicFilters.forEach((df) => {
+      const dep = df.DependencyFieldLabel ?? df.dependencyFieldLabel;
+      const master = df.MasterFieldLabel ?? df.masterFieldLabel ?? dep;
+      if (!dep) return;
+      const src = elements.find((e) => e.label === dep);
+      const v = src ? text(values[src.elementId]) : "";
+      filters2.push({ ...base2, kind: "dynamic", masterField: master, sourceLabel: dep, sourceValue: v || "(empty)", active: !!v });
+    });
+    cfg.staticFilters.forEach((sf) => {
+      const label = sf.label ?? sf.Label ?? sf.MasterFieldLabel ?? sf.field ?? "?";
+      filters2.push({ ...base2, kind: "static", masterField: String(label), value: text(sf.value ?? sf.Value ?? sf.arr_value), active: true });
+    });
+  });
+  const validation = [];
+  form.fields.forEach((f) => {
+    const t = resolveFieldType(f.element);
+    if (NON_INPUT_TYPES.has(t) || t === "INPUT_FORMULA" || t === "INPUT_SHEET") return;
+    validation.push({
+      id: f.id,
+      label: f.label,
+      type: t,
+      required: f.required,
+      hidden: f.hidden,
+      checks: checksOf(f.element, f.required),
+      value: formatFieldValue(f.element, f.value),
+      error: f.hidden ? void 0 : validateField(f.element, f.value, f.required),
+      shownError: f.error
+    });
+  });
+  const formulas = formulaRows(elements, values, "form");
+  const sheets = [];
+  elements.forEach((el2) => {
+    const t = resolveFieldType(el2);
+    if (t !== "INPUT_SHEET" && t !== "INPUT_CHILD_WIDGET") return;
+    const child = form.sheetDefinition(el2.elementId);
+    if (!child) return;
+    const rows = (Array.isArray(values[el2.elementId]) ? values[el2.elementId] : []).filter((r) => r && typeof r === "object");
+    const sheet = { fieldId: el2.elementId, label: el2.label, formId: child.uuid ?? "", rows: [] };
+    rows.forEach((row, i) => {
+      const { _submissionId, _dirty, _rowKey, ...cells } = row;
+      const scope = `${el2.label} \xB7 row ${i + 1}`;
+      if (sheetRowNeedsCheck(row)) {
+        child.elements.forEach((c) => {
+          if (!sheetCellChecked(c) || resolveFieldType(c) === "INPUT_FORMULA") return;
+          validation.push({
+            id: `${el2.elementId}:${i}:${c.elementId}`,
+            label: c.label,
+            type: resolveFieldType(c),
+            scope,
+            required: !!c.required,
+            hidden: false,
+            checks: checksOf(c, !!c.required),
+            value: formatFieldValue(c, cells[c.elementId]),
+            error: validateField(c, cells[c.elementId])
+          });
+        });
+      }
+      const fresh = computeRowFormulas(child.elements, cells);
+      formulas.push(...formulaRows(child.elements, cells, "row", { sheetLabel: el2.label, row: i + 1, expectedRow: fresh }));
+      sheet.rows.push(buildSubmissionElements(child.elements, fresh));
+    });
+    sheets.push(sheet);
+  });
+  const defaults = [];
+  elements.forEach((el2) => {
+    const dd = el2.attributes?.dynamicDefault;
+    const ds = el2.properties?.dataSource ?? {};
+    let source = "";
+    if (dd && typeof dd === "object") {
+      const u = dd.units ?? {};
+      const parts = Object.entries(u).filter(([, n]) => Number(n)).map(([k, n]) => `${n} ${k}`);
+      source = dd.type ? String(dd.type) : `today ${String(dd.operator ?? "ADD") === "SUB" ? "\u2212" : "+"} ${parts.join(" ") || "0"}`;
+    } else if (typeof dd === "string" && dd) source = dd;
+    else if (ds.DynamicDefaultSelectLabel || ds.DynamicDefault) source = `current user's ${ds.DynamicDefaultSelectLabel ?? ds.DynamicDefault}`;
+    else if (resolveFieldType(el2) === "ON_BEHALF_OF") source = "current user";
+    else if (el2.defaultValue !== null && el2.defaultValue !== void 0 && el2.defaultValue !== "" && resolveFieldType(el2) !== "INPUT_SHEET") source = `fixed: ${text(el2.defaultValue)}`;
+    if (source) defaults.push({ id: el2.elementId, label: el2.label, source, value: formatFieldValue(el2, values[el2.elementId]) });
+  });
+  const submitEls = submitElementsOf(elements);
+  const sheetIds = new Set(sheets.map((s) => s.fieldId));
+  const shown = { ...values };
+  sheets.forEach((s) => {
+    shown[s.fieldId] = s.rows.map((_2, i) => `\u2039row ${i + 1} id\u203A`);
+  });
+  const parent = buildSubmissionElements(submitEls, shown).map((e) => sheetIds.has(e.elementId) ? { elementId: e.elementId, value: shown[e.elementId] } : e);
+  const payload = { formId: def.uuid ?? "", elements: parent.map(({ properties, ...rest }) => rest), sheets };
+  const errors = validation.filter((v) => !v.hidden && v.error).length;
+  const formulaIssues = formulas.filter((f) => !f.serverSafe || !f.inSync).length;
+  return {
+    rules,
+    filters: filters2,
+    validation,
+    formulas,
+    defaults,
+    payload,
+    summary: {
+      rules: rules.length,
+      matched: rules.filter((r) => r.matched).length,
+      filters: filters2.length,
+      activeFilters: filters2.filter((f) => f.active).length,
+      errors,
+      formulas: formulas.length,
+      formulaIssues
+    }
+  };
+}
+function useFormInspector(form) {
+  return React14.useMemo(() => inspectForm(form), [form.definition, form.values, form.sheetVersion, form.fields]);
+}
 
 // src/forms/authoring.ts
 var slug = (s) => s.toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_|_$/g, "").slice(0, 32);
@@ -8062,6 +9240,7 @@ function formWidget(o) {
 exports.ActionCardWidget = ActionCardWidget;
 exports.ActivityFeedWidget = ActivityFeedWidget;
 exports.AreaChartWidget = AreaChartWidget;
+exports.BLOCKED_FILE_EXTENSIONS = BLOCKED_FILE_EXTENSIONS;
 exports.BannerWidget = BannerWidget;
 exports.BarChartWidget = BarChartWidget;
 exports.COLUMN_FILTER_BLANK = COLUMN_FILTER_BLANK;
@@ -8126,8 +9305,10 @@ exports.ZvolvForm = ZvolvForm;
 exports.ZvolvProvider = ZvolvProvider;
 exports.ZvolvThemeProvider = ZvolvThemeProvider;
 exports.ZvolvWidget = ZvolvWidget;
+exports.addPeriod = addPeriod;
 exports.aggregate = aggregate;
 exports.alignSummaryToSeries = alignSummaryToSeries;
+exports.applyCumulative = applyCumulative;
 exports.applyLocalColumnFilters = applyLocalColumnFilters;
 exports.applyLocalSearch = applyLocalSearch;
 exports.applyLocalSort = applyLocalSort;
@@ -8151,11 +9332,13 @@ exports.childIdsOf = childIdsOf;
 exports.cleanTitle = cleanTitle;
 exports.clearLookupCache = clearLookupCache;
 exports.coerceSeriesNumbers = coerceSeriesNumbers;
+exports.computeRowFormulas = computeRowFormulas;
 exports.createMockRuntime = createMockRuntime;
 exports.createSubmission = createSubmission;
 exports.createZvolvRuntime = createZvolvRuntime;
 exports.dashboardDefaultDateToken = dashboardDefaultDateToken;
 exports.dashboardFilterDefs = dashboardFilterDefs;
+exports.dateDiff = dateDiff;
 exports.dateRangeFor = dateRangeFor;
 exports.defaultTokens = defaultTokens;
 exports.defineConfig = defineConfig;
@@ -8166,6 +9349,7 @@ exports.distinctColumnValues = distinctColumnValues;
 exports.eid = eid;
 exports.el = el;
 exports.evaluateFormula = evaluateFormula;
+exports.extractAgentFormData = extractAgentFormData;
 exports.fetchForm = fetchForm;
 exports.fetchLookupOptions = fetchLookupOptions;
 exports.fetchSubmission = fetchSubmission;
@@ -8174,6 +9358,7 @@ exports.fieldKind = fieldKind;
 exports.fieldKindOf = fieldKindOf;
 exports.fillDateGaps = fillDateGaps;
 exports.filterableFields = filterableFields;
+exports.flattenPercentiles = flattenPercentiles;
 exports.formSource = formSource;
 exports.formWidget = formWidget;
 exports.formatAmountValue = formatAmountValue;
@@ -8188,20 +9373,27 @@ exports.gridHeight = gridHeight;
 exports.gridWidgets = gridWidgets;
 exports.groupBy = groupBy;
 exports.hasActiveInteractions = hasActiveInteractions;
+exports.inspectForm = inspectForm;
 exports.interpolate = interpolate;
+exports.invokeAgent = invokeAgent;
 exports.invokeTrigger = invokeTrigger;
+exports.invokeZeno = invokeZeno;
 exports.isDataSourceConfigured = isDataSourceConfigured;
 exports.isLegacyId = isLegacyId;
 exports.isLikelyTimestamp = isLikelyTimestamp;
+exports.isServerSafeFormula = isServerSafeFormula;
 exports.lookupConfigOf = lookupConfigOf;
 exports.mergeTokens = mergeTokens;
 exports.normaliseElement = normaliseElement;
 exports.normaliseForm = normaliseForm;
 exports.normalizeWidget = normalizeWidget;
+exports.openFormRequest = openFormRequest;
 exports.operatorsForKind = operatorsForKind;
 exports.optionFilterRules = optionFilterRules;
 exports.parseConfig = parseConfig;
+exports.parseDateValue = parseDateValue;
 exports.parseDeep = parseDeep;
+exports.percentileKey = percentileKey;
 exports.pivot = pivot;
 exports.renderHtmlVariables = renderHtmlVariables;
 exports.resetQueryUser = resetQueryUser;
@@ -8221,13 +9413,17 @@ exports.resolveWidgetDefaults = resolveWidgetDefaults;
 exports.resolveXKey = resolveXKey;
 exports.rowSubmissionIds = rowSubmissionIds;
 exports.ruleMatches = ruleMatches;
+exports.rulesOf = rulesOf;
 exports.searchPeople = searchPeople;
 exports.serializeElementValue = serializeElementValue;
+exports.startOfPeriod = startOfPeriod;
 exports.statusTone = statusTone;
 exports.submissionIdOf = submissionIdOf;
 exports.submissionToValues = submissionToValues;
+exports.submitElementsOf = submitElementsOf;
 exports.taskField = taskField;
 exports.taskSource = taskSource;
+exports.toBraceFormula = toBraceFormula;
 exports.toNum = toNum;
 exports.toRelational = toRelational;
 exports.toneColor = toneColor;
@@ -8238,6 +9434,7 @@ exports.useCollectionItems = useCollectionItems;
 exports.useFieldOptions = useFieldOptions;
 exports.useFileField = useFileField;
 exports.useFormApi = useFormApi;
+exports.useFormInspector = useFormInspector;
 exports.useInteractiveWidgetData = useInteractiveWidgetData;
 exports.useKpiContents = useKpiContents;
 exports.useSheetField = useSheetField;
@@ -8245,6 +9442,7 @@ exports.useTableColumns = useTableColumns;
 exports.useTemplateOverride = useTemplateOverride;
 exports.useTemporalEvents = useTemporalEvents;
 exports.useTokens = useTokens;
+exports.useTrialField = useTrialField;
 exports.useWidgetData = useWidgetData;
 exports.useWidgetInteractions = useWidgetInteractions;
 exports.useZvolvClient = useZvolvClient;