formanitor 0.1.10 → 0.2.0

package/dist/chunk-ZGPHTPAN.mjs

@@ -0,0 +1,1851 @@
+import { createContext, useContext, useRef, useEffect, useState, useCallback } from 'react';
+import { jsx } from 'react/jsx-runtime';
+
+// src/core/validate.ts
+var EMAIL_REGEX = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+function validateField(value, field, allValues) {
+  if (field.hidden || field.disabled) return null;
+  if (field.type === "otp_input") {
+    if (field.required) {
+      if (!value || typeof value !== "object" || value.verified !== true) {
+        return "Please verify your mobile number with OTP";
+      }
+      const otpField = field;
+      const phoneFieldId = otpField.meta?.phoneFieldId ?? "phone";
+      if (allValues) {
+        const phoneRaw = allValues[phoneFieldId] ?? "";
+        const e164 = phoneRaw.startsWith("+") ? phoneRaw : `+91${phoneRaw}`;
+        if (value.phone && value.phone !== e164) {
+          return "Mobile number changed \u2014 please re-verify";
+        }
+      }
+    }
+    return null;
+  }
+  if (field.required) {
+    if (value === null || value === void 0 || value === "") {
+      return "This field is required";
+    }
+    if (Array.isArray(value) && value.length === 0) {
+      return "This field is required";
+    }
+    if (field.type === "smart_textarea" && typeof value === "object" && !Array.isArray(value)) {
+      if (!value.text || value.text.trim() === "") {
+        return "This field is required";
+      }
+    }
+  }
+  if (value === null || value === void 0 || value === "") {
+    return null;
+  }
+  const rules = field.validation;
+  if (!rules) return null;
+  if (field.type === "number") {
+    const num = Number(value);
+    if (isNaN(num)) return "Must be a valid number";
+    if (rules.min !== void 0 && num < rules.min) {
+      return `Must be at least ${rules.min}`;
+    }
+    if (rules.max !== void 0 && num > rules.max) {
+      return `Must be at most ${rules.max}`;
+    }
+  }
+  if (field.type === "slider") {
+    const num = Number(value);
+    if (isNaN(num)) return "Must be a valid number";
+    const s = field;
+    const min = s.min ?? 0;
+    const max = s.max ?? 10;
+    if (num < min) return `Must be at least ${min}`;
+    if (num > max) return `Must be at most ${max}`;
+  }
+  if (typeof value === "string") {
+    if (rules.minLength !== void 0 && value.length < rules.minLength) {
+      return `Must be at least ${rules.minLength} characters`;
+    }
+    if (rules.maxLength !== void 0 && value.length > rules.maxLength) {
+      return `Must be at most ${rules.maxLength} characters`;
+    }
+    if (rules.pattern) {
+      const regex = new RegExp(rules.pattern);
+      if (!regex.test(value)) {
+        return "Invalid format";
+      }
+    }
+  }
+  if (rules.custom) {
+    return rules.custom(value);
+  }
+  return null;
+}
+function validateForm(values, fields) {
+  const errors = {};
+  for (const [key, field] of Object.entries(fields)) {
+    if (field.type === "static_text") continue;
+    const error = validateField(values[key], field, values);
+    if (error) {
+      errors[key] = error;
+    }
+  }
+  return errors;
+}
+
+// src/core/suggestionTokens.ts
+function getSuggestionTokensFromText(text) {
+  return text.split(/[,\n\r]+/).map((p) => p.trim()).filter(Boolean);
+}
+var DEFAULT_TOKEN_SEPARATOR = ", ";
+function commaSplitLine(line) {
+  return line.split(",").map((p) => p.trim()).filter(Boolean);
+}
+function dedupeChipOrder(chips) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const c of chips) {
+    if (seen.has(c)) continue;
+    seen.add(c);
+    out.push(c);
+  }
+  return out;
+}
+function parseProseAndChipTokens(text, allowed) {
+  const normalized = text.replace(/\r\n/g, "\n");
+  let lines = normalized.split("\n");
+  while (lines.length > 0 && lines[lines.length - 1] === "") {
+    lines.pop();
+  }
+  if (lines.length === 0) return { prose: "", chips: [] };
+  let chipStart = lines.length;
+  for (let i = lines.length - 1; i >= 0; i--) {
+    const toks = commaSplitLine(lines[i]);
+    if (toks.length === 0) break;
+    if (!toks.every((t) => allowed.has(t))) break;
+    chipStart = i;
+  }
+  if (chipStart < lines.length) {
+    const chipLines = lines.slice(chipStart);
+    const prose = lines.slice(0, chipStart).join("\n");
+    const chips = dedupeChipOrder(chipLines.flatMap(commaSplitLine));
+    return { prose, chips };
+  }
+  const parts = getSuggestionTokensFromText(normalized);
+  const chipsFallback = dedupeChipOrder(parts.filter((t) => allowed.has(t)));
+  const proseParts = parts.filter((t) => !allowed.has(t));
+  return { prose: proseParts.join(DEFAULT_TOKEN_SEPARATOR), chips: chipsFallback };
+}
+function composeProseAndChips(prose, chips, separator = DEFAULT_TOKEN_SEPARATOR) {
+  const chipStr = dedupeChipOrder(chips).join(separator);
+  const p = prose.replace(/\s+$/, "");
+  if (p && chipStr) return `${p}
+${chipStr}`;
+  if (chipStr) return chipStr;
+  return p;
+}
+function toggleSuggestionTokenInText(current, token, separator = DEFAULT_TOKEN_SEPARATOR, allowedChipValues) {
+  const t = String(token).trim();
+  if (!t) return current;
+  if (!allowedChipValues || allowedChipValues.size === 0) {
+    const parts = getSuggestionTokensFromText(current);
+    const i = parts.findIndex((p) => p === t);
+    if (i >= 0) parts.splice(i, 1);
+    else parts.push(t);
+    return parts.join(separator);
+  }
+  if (!allowedChipValues.has(t)) return current;
+  let { prose, chips } = parseProseAndChipTokens(current, allowedChipValues);
+  const idx = chips.indexOf(t);
+  if (idx >= 0) chips.splice(idx, 1);
+  else chips.push(t);
+  chips = dedupeChipOrder(chips);
+  return composeProseAndChips(prose, chips, separator);
+}
+
+// src/core/rules.ts
+function tokenListContainsString(text, needle) {
+  if (typeof text !== "string") return false;
+  const want = String(needle).trim();
+  if (!want) return false;
+  const parts = getSuggestionTokensFromText(text);
+  return parts.includes(want);
+}
+function evaluateCondition(value, condition) {
+  switch (condition.op) {
+    case "==":
+      return value == condition.value;
+    // Loose equality for flexibility
+    case "!=":
+      return value != condition.value;
+    case ">":
+      return Number(value) > Number(condition.value);
+    case "<":
+      return Number(value) < Number(condition.value);
+    case ">=":
+      return Number(value) >= Number(condition.value);
+    case "<=":
+      return Number(value) <= Number(condition.value);
+    case "in":
+      return Array.isArray(condition.value) && condition.value.includes(value);
+    case "contains":
+      if (Array.isArray(value)) {
+        return value.includes(condition.value);
+      }
+      if (typeof value === "string") {
+        return tokenListContainsString(value, condition.value);
+      }
+      return false;
+    default:
+      return false;
+  }
+}
+function evaluateRules(values, rules, fields) {
+  const result = {
+    visibility: {},
+    disabled: {},
+    required: {}
+  };
+  Object.keys(fields).forEach((key) => {
+    result.visibility[key] = !fields[key].hidden;
+    result.disabled[key] = !!fields[key].disabled;
+    result.required[key] = !!fields[key].required;
+  });
+  if (!rules) return result;
+  rules.forEach((rule) => {
+    const targetField = rule.if.field;
+    if (!targetField) return;
+    const sourceValue = values[targetField];
+    const isMatch = evaluateCondition(sourceValue, rule.if);
+    if (isMatch) {
+      rule.then.forEach((action) => {
+        applyAction(result, action);
+      });
+    }
+  });
+  return result;
+}
+function applyAction(result, action) {
+  switch (action.action) {
+    case "hide":
+      result.visibility[action.target] = false;
+      break;
+    case "show":
+      result.visibility[action.target] = true;
+      break;
+    case "disable":
+      result.disabled[action.target] = true;
+      break;
+    case "enable":
+      result.disabled[action.target] = false;
+      break;
+    case "setRequired":
+      result.required[action.target] = true;
+      break;
+  }
+}
+
+// src/core/generalSurgeryPathway.ts
+var defaultGeneralSurgerySmartHistory = () => ({
+  pain: {
+    site: "",
+    onset: "",
+    character: "",
+    radiation: "",
+    associated: "",
+    timing: "",
+    exacerbating: "",
+    severity: 0
+  },
+  swelling: { duration: "", sizeProgression: "", painfulPainless: "", checks: [] },
+  gi: { appetite: "", weightLoss: "", bowelHabits: "", checks: [] },
+  breast: { lumpDuration: "", nippleDischarge: "", checks: [] },
+  ano: { checks: [] },
+  thyroid: { swellingDuration: "", checks: [] }
+});
+var defaultBreastExamSide = () => ({
+  size: "",
+  quadrant: "",
+  tenderness: "",
+  fixity: "",
+  skinInvolvement: "",
+  consistency: "",
+  axillaryNodes: false,
+  nippleAreolarComplex: false
+});
+var defaultBreastExaminationBlock = () => ({
+  left: defaultBreastExamSide(),
+  right: defaultBreastExamSide()
+});
+var defaultGeneralSurgeryExamination = () => ({
+  general: [],
+  regions: [],
+  abdomen: {
+    inspection: [],
+    palpation: [],
+    percussion: [],
+    massNotes: "",
+    bowelSounds: "none"
+  },
+  hernia: { site: "", reducible: false, coughImpulse: false, tenderness: false },
+  breast: defaultBreastExaminationBlock(),
+  thyroid: { size: "", mobileDeglutition: false, nodules: false, cervicalNodes: false },
+  anorectal: { inspection: "", dreDone: false, proctoscopyDone: false, notes: "" },
+  limb: { dilatedVeins: false, ulcer: false, oedema: false }
+});
+var ALL_GS_CONDITIONS = [
+  "hernia",
+  "appendicitis",
+  "gallbladder",
+  "breast",
+  "thyroid",
+  "piles",
+  "varicose",
+  "ulcer"
+];
+var defaultGeneralSurgeryGrading = () => ({
+  hernia: 0,
+  appendicitis: 0,
+  gallbladder: 0,
+  breast: 0,
+  thyroid: 0,
+  piles: 0,
+  varicose: 0,
+  ulcer: 0
+});
+var GS_CONDITION_TRIGGERS = {
+  hernia: { regions: ["hernia", "abdomen"], chips: ["swelling_lump", "obstruction"] },
+  appendicitis: { regions: ["abdomen"], chips: ["pain", "obstruction"] },
+  gallbladder: { regions: ["abdomen"], chips: ["pain"] },
+  breast: { regions: ["breast"], chips: ["breast", "swelling_lump"] },
+  thyroid: { regions: ["thyroid"], chips: ["thyroid", "swelling_lump"] },
+  piles: { regions: ["anorectal"], chips: ["anorectal", "bleeding"] },
+  varicose: { regions: ["limb"], chips: ["swelling_lump"] },
+  ulcer: { regions: ["limb", "anorectal"], chips: ["ulcer_wound", "discharge"] }
+};
+var GS_CONDITION_LABELS = {
+  hernia: "Hernia",
+  appendicitis: "Appendicitis",
+  gallbladder: "Gallbladder disease",
+  breast: "Breast lump (BIRADS)",
+  thyroid: "Thyroid nodule (TIRADS)",
+  piles: "Haemorrhoids",
+  varicose: "Varicose veins (CEAP)",
+  ulcer: "Ulcer / wound"
+};
+var GS_GRADE_DESCRIPTIONS = {
+  hernia: ["\u2014", "Small reducible", "Large reducible", "Irreducible", "Obstructed", "Strangulated"],
+  appendicitis: ["\u2014", "Mild (clinical)", "Confirmed (USG/CT)", "Complicated (mass)", "Abscess", "Perforation"],
+  gallbladder: ["\u2014", "Asymptomatic stones", "Symptomatic", "Acute cholecystitis", "Complicated (CBD stone)", "Perforation/empyema"],
+  breast: ["\u2014", "BIRADS 1 \u2014 Negative", "BIRADS 2 \u2014 Benign", "BIRADS 3 \u2014 Probably benign", "BIRADS 4 \u2014 Suspicious", "BIRADS 5 \u2014 Malignant"],
+  thyroid: ["\u2014", "TIRADS 1 \u2014 Normal", "TIRADS 2 \u2014 Benign", "TIRADS 3 \u2014 Indeterminate", "TIRADS 4 \u2014 Suspicious", "TIRADS 5 \u2014 Highly suspicious"],
+  piles: ["\u2014", "Grade 1", "Grade 2", "Grade 3", "Grade 4", "Grade 5"],
+  varicose: ["\u2014", "C1 telangiectasia", "C2 varicose", "C3 oedema", "C4 skin changes", "C5-C6 ulcer"],
+  ulcer: ["\u2014", "Superficial", "Deep", "Infected", "Necrotic", "Gangrene"]
+};
+function normalizeGeneralSurgerySmartHistory(raw) {
+  const d = defaultGeneralSurgerySmartHistory();
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return d;
+  const v = raw;
+  const painIn = v.pain && typeof v.pain === "object" ? v.pain : {};
+  const sev = Number(painIn.severity);
+  const pain = {
+    ...d.pain,
+    ...painIn,
+    severity: Number.isFinite(sev) ? Math.min(10, Math.max(0, Math.round(sev))) : d.pain.severity
+  };
+  const str2 = (x) => typeof x === "string" ? x : "";
+  const strArr = (x) => Array.isArray(x) ? x.filter((i) => typeof i === "string") : [];
+  const swell = v.swelling && typeof v.swelling === "object" ? v.swelling : {};
+  const gi = v.gi && typeof v.gi === "object" ? v.gi : {};
+  const breast = v.breast && typeof v.breast === "object" ? v.breast : {};
+  const ano = v.ano && typeof v.ano === "object" ? v.ano : {};
+  const thy = v.thyroid && typeof v.thyroid === "object" ? v.thyroid : {};
+  return {
+    pain,
+    swelling: {
+      duration: str2(swell.duration),
+      sizeProgression: str2(swell.sizeProgression),
+      painfulPainless: str2(swell.painfulPainless),
+      checks: strArr(swell.checks)
+    },
+    gi: {
+      appetite: str2(gi.appetite),
+      weightLoss: str2(gi.weightLoss),
+      bowelHabits: str2(gi.bowelHabits),
+      checks: strArr(gi.checks)
+    },
+    breast: {
+      lumpDuration: str2(breast.lumpDuration),
+      nippleDischarge: str2(breast.nippleDischarge),
+      checks: strArr(breast.checks)
+    },
+    ano: { checks: strArr(ano.checks) },
+    thyroid: {
+      swellingDuration: str2(thy.swellingDuration),
+      checks: strArr(thy.checks)
+    }
+  };
+}
+function normalizeBreastExamSide(partial) {
+  const e = defaultBreastExamSide();
+  const str2 = (x) => typeof x === "string" ? x : "";
+  const bool2 = (x) => x === true;
+  if (!partial || typeof partial !== "object") return e;
+  const p = partial;
+  return {
+    size: str2(p.size),
+    quadrant: str2(p.quadrant),
+    tenderness: str2(p.tenderness),
+    fixity: str2(p.fixity),
+    skinInvolvement: str2(p.skinInvolvement),
+    consistency: str2(p.consistency),
+    axillaryNodes: bool2(p.axillaryNodes),
+    nippleAreolarComplex: bool2(p.nippleAreolarComplex)
+  };
+}
+function normalizeBreastExaminationBlock(raw) {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return defaultBreastExaminationBlock();
+  const br = raw;
+  return {
+    left: normalizeBreastExamSide(br.left),
+    right: normalizeBreastExamSide(br.right)
+  };
+}
+function normalizeGeneralSurgeryExamination(raw) {
+  const d = defaultGeneralSurgeryExamination();
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return d;
+  const v = raw;
+  const strArr = (x) => Array.isArray(x) ? x.filter((i) => typeof i === "string") : [];
+  const ab = v.abdomen && typeof v.abdomen === "object" ? v.abdomen : {};
+  const bowel = ab.bowelSounds;
+  const bowels = bowel === "normal" || bowel === "up" || bowel === "down" || bowel === "absent" ? bowel : "none";
+  const hb = v.hernia && typeof v.hernia === "object" ? v.hernia : {};
+  const br = v.breast && typeof v.breast === "object" ? v.breast : {};
+  const th = v.thyroid && typeof v.thyroid === "object" ? v.thyroid : {};
+  const ar = v.anorectal && typeof v.anorectal === "object" ? v.anorectal : {};
+  const lm = v.limb && typeof v.limb === "object" ? v.limb : {};
+  const bool2 = (x) => x === true;
+  return {
+    general: strArr(v.general),
+    regions: strArr(v.regions),
+    abdomen: {
+      inspection: strArr(ab.inspection),
+      palpation: strArr(ab.palpation),
+      percussion: strArr(ab.percussion),
+      massNotes: typeof ab.massNotes === "string" ? ab.massNotes : d.abdomen.massNotes,
+      bowelSounds: bowels
+    },
+    hernia: {
+      site: typeof hb.site === "string" ? hb.site : "",
+      reducible: bool2(hb.reducible),
+      coughImpulse: bool2(hb.coughImpulse),
+      tenderness: bool2(hb.tenderness)
+    },
+    breast: normalizeBreastExaminationBlock(br),
+    thyroid: {
+      size: typeof th.size === "string" ? th.size : "",
+      mobileDeglutition: bool2(th.mobileDeglutition),
+      nodules: bool2(th.nodules),
+      cervicalNodes: bool2(th.cervicalNodes)
+    },
+    anorectal: {
+      inspection: typeof ar.inspection === "string" ? ar.inspection : "",
+      dreDone: bool2(ar.dreDone),
+      proctoscopyDone: bool2(ar.proctoscopyDone),
+      notes: typeof ar.notes === "string" ? ar.notes : ""
+    },
+    limb: {
+      dilatedVeins: bool2(lm.dilatedVeins),
+      ulcer: bool2(lm.ulcer),
+      oedema: bool2(lm.oedema)
+    }
+  };
+}
+function normalizeGeneralSurgeryGrading(raw) {
+  const d = defaultGeneralSurgeryGrading();
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return d;
+  const v = raw;
+  const out = { ...d };
+  for (const k of ALL_GS_CONDITIONS) {
+    const n = Number(v[k]);
+    if (Number.isFinite(n) && n >= 0 && n <= 5) out[k] = Math.round(n);
+  }
+  return out;
+}
+function gsGradingRowVisible(cond, chips, regions, grade) {
+  if (grade > 0) return true;
+  const t = GS_CONDITION_TRIGGERS[cond];
+  if (t.chips.some((c) => chips.includes(c))) return true;
+  if (t.regions.some((r) => regions.includes(r))) return true;
+  return false;
+}
+var SWELLING_OPT_LABELS = {
+  reducible_hernia: "Reducible (hernia)",
+  cough_impulse: "Cough impulse",
+  skin_changes: "Skin changes"
+};
+var GI_OPT_LABELS = {
+  bleeding_pr: "Bleeding PR",
+  vomiting: "Vomiting",
+  haematemesis: "Haematemesis"
+};
+var BREAST_OPT_LABELS = {
+  pain: "Pain",
+  fh_ca_breast: "Family history of Ca breast"
+};
+var ANO_OPT_LABELS = {
+  pain_defecation: "Pain during defecation",
+  bleeding: "Bleeding",
+  constipation: "Constipation",
+  discharge: "Discharge"
+};
+var THYROID_OPT_LABELS = {
+  dysphagia: "Dysphagia",
+  voice_change: "Voice change",
+  thyrotoxicosis: "Thyrotoxicosis symptoms"
+};
+var SOCRATES_LABELS = {
+  site: "Site",
+  onset: "Onset",
+  character: "Character",
+  radiation: "Radiation",
+  associated: "Associated",
+  timing: "Timing",
+  exacerbating: "Exacerbating / relieving"
+};
+var GENERAL_EXAM_LABELS = {
+  pallor: "Pallor",
+  icterus: "Icterus",
+  cyanosis: "Cyanosis",
+  clubbing: "Clubbing",
+  lymphadenopathy: "Lymphadenopathy",
+  oedema: "Oedema"
+};
+var REGION_EXAM_LABELS = {
+  abdomen: "Abdomen",
+  hernia: "Hernia",
+  breast: "Breast",
+  thyroid: "Thyroid",
+  anorectal: "Anorectal",
+  limb: "Limb / varicose"
+};
+var ABD_INSP_LABELS = {
+  distension: "Distension",
+  scars: "Scars",
+  visible_peristalsis: "Visible peristalsis"
+};
+var ABD_PALP_LABELS = {
+  tenderness: "Tenderness",
+  guarding: "Guarding",
+  rigidity: "Rigidity",
+  mass: "Palpable mass"
+};
+var ABD_PERC_LABELS = {
+  tympany: "Tympany",
+  shifting_dullness: "Shifting dullness"
+};
+function trimLine(s) {
+  return s.replace(/\s+/g, " ").trim();
+}
+var SK_ORDER = ["site", "onset", "character", "radiation", "associated", "timing", "exacerbating"];
+function formatGeneralSurgerySmartHistoryToNarrative(v, chips) {
+  const blocks = [];
+  const showPain = chips.includes("pain");
+  const showSwelling = chips.includes("swelling_lump");
+  const showGI = chips.includes("bleeding") || chips.includes("obstruction");
+  const showBreast = chips.includes("breast");
+  const showAno = chips.includes("anorectal");
+  const showThyroid = chips.includes("thyroid");
+  if (showPain) {
+    const painLines = [];
+    for (const key of SK_ORDER) {
+      const raw = v.pain[key];
+      if (typeof raw === "string" && raw.trim()) {
+        painLines.push(`${SOCRATES_LABELS[key]}: ${trimLine(raw)}`);
+      }
+    }
+    if (v.pain.severity > 0) {
+      painLines.push(`Severity (0\u201310): ${v.pain.severity}`);
+    }
+    if (painLines.length > 0) {
+      blocks.push(["SOCRATES \u2014 pain", ...painLines.map((l) => `\u2022 ${l}`)].join("\n"));
+    }
+  }
+  if (showSwelling) {
+    const parts = [];
+    if (v.swelling.duration.trim()) parts.push(`Duration: ${trimLine(v.swelling.duration)}`);
+    if (v.swelling.sizeProgression.trim())
+      parts.push(`Size progression: ${trimLine(v.swelling.sizeProgression)}`);
+    if (v.swelling.painfulPainless.trim())
+      parts.push(`Painful / painless: ${trimLine(v.swelling.painfulPainless)}`);
+    for (const c of v.swelling.checks) {
+      const lb = SWELLING_OPT_LABELS[c] ?? c;
+      parts.push(lb);
+    }
+    if (parts.length > 0) {
+      blocks.push(["Swelling history", ...parts.map((p) => `\u2022 ${p}`)].join("\n"));
+    }
+  }
+  if (showGI) {
+    const parts = [];
+    if (v.gi.appetite.trim()) parts.push(`Appetite: ${trimLine(v.gi.appetite)}`);
+    if (v.gi.weightLoss.trim()) parts.push(`Weight loss: ${trimLine(v.gi.weightLoss)}`);
+    if (v.gi.bowelHabits.trim()) parts.push(`Bowel habits: ${trimLine(v.gi.bowelHabits)}`);
+    for (const c of v.gi.checks) {
+      parts.push(GI_OPT_LABELS[c] ?? c);
+    }
+    if (parts.length > 0) {
+      blocks.push(["GI history", ...parts.map((p) => `\u2022 ${p}`)].join("\n"));
+    }
+  }
+  if (showBreast) {
+    const parts = [];
+    if (v.breast.lumpDuration.trim()) parts.push(`Lump duration: ${trimLine(v.breast.lumpDuration)}`);
+    if (v.breast.nippleDischarge.trim())
+      parts.push(`Nipple discharge: ${trimLine(v.breast.nippleDischarge)}`);
+    for (const c of v.breast.checks) {
+      parts.push(BREAST_OPT_LABELS[c] ?? c);
+    }
+    if (parts.length > 0) {
+      blocks.push(["Breast history", ...parts.map((p) => `\u2022 ${p}`)].join("\n"));
+    }
+  }
+  if (showAno) {
+    const parts = [];
+    for (const c of v.ano.checks) {
+      parts.push(ANO_OPT_LABELS[c] ?? c);
+    }
+    if (parts.length > 0) {
+      blocks.push(["Anorectal history", ...parts.map((p) => `\u2022 ${p}`)].join("\n"));
+    }
+  }
+  if (showThyroid) {
+    const parts = [];
+    if (v.thyroid.swellingDuration.trim())
+      parts.push(`Swelling duration: ${trimLine(v.thyroid.swellingDuration)}`);
+    for (const c of v.thyroid.checks) {
+      parts.push(THYROID_OPT_LABELS[c] ?? c);
+    }
+    if (parts.length > 0) {
+      blocks.push(["Thyroid history", ...parts.map((p) => `\u2022 ${p}`)].join("\n"));
+    }
+  }
+  return blocks.join("\n\n");
+}
+var BOWEL_SOUND_LABELS = {
+  none: "\u2014",
+  normal: "Normal",
+  up: "Increased (\u2191)",
+  down: "Decreased (\u2193)",
+  absent: "Absent"
+};
+function formatGeneralSurgeryExaminationToNarrative(v) {
+  const blocks = [];
+  const generalPositive = v.general.map((k) => GENERAL_EXAM_LABELS[k] ?? k).filter(Boolean);
+  if (generalPositive.length > 0) {
+    blocks.push(
+      ["General examination", ...generalPositive.map((g) => `\u2022 ${g}`)].join("\n")
+    );
+  }
+  if (v.regions.length > 0) {
+    const names = v.regions.map((r) => REGION_EXAM_LABELS[r] ?? r);
+    blocks.push(`Regional examination: ${names.join(", ")}`);
+  }
+  if (v.regions.includes("abdomen")) {
+    const sub = [];
+    const ins = v.abdomen.inspection.map((x) => ABD_INSP_LABELS[x] ?? x);
+    const pal = v.abdomen.palpation.map((x) => ABD_PALP_LABELS[x] ?? x);
+    const per = v.abdomen.percussion.map((x) => ABD_PERC_LABELS[x] ?? x);
+    if (ins.length) sub.push(`Inspection: ${ins.join(", ")}`);
+    if (pal.length) sub.push(`Palpation: ${pal.join(", ")}`);
+    if (v.abdomen.massNotes.trim()) sub.push(`Mass / mobility: ${trimLine(v.abdomen.massNotes)}`);
+    if (per.length) sub.push(`Percussion: ${per.join(", ")}`);
+    const bs = BOWEL_SOUND_LABELS[v.abdomen.bowelSounds];
+    if (v.abdomen.bowelSounds !== "none") {
+      sub.push(`Bowel sounds: ${bs}`);
+    }
+    if (sub.length > 0) {
+      blocks.push(["Abdomen", ...sub.map((s) => `\u2022 ${s}`)].join("\n"));
+    }
+  }
+  if (v.regions.includes("hernia")) {
+    const sub = [];
+    if (v.hernia.site.trim()) sub.push(`Site: ${trimLine(v.hernia.site)}`);
+    if (v.hernia.reducible) sub.push("Reducible");
+    if (v.hernia.coughImpulse) sub.push("Cough impulse positive");
+    if (v.hernia.tenderness) sub.push("Tenderness");
+    if (sub.length > 0) {
+      blocks.push(["Hernia", ...sub.map((s) => `\u2022 ${s}`)].join("\n"));
+    }
+  }
+  if (v.regions.includes("breast")) {
+    const sub = [];
+    const appendSide = (label, s) => {
+      const lines = [];
+      if (s.size.trim()) lines.push(`Size: ${trimLine(s.size)}`);
+      if (s.quadrant.trim()) lines.push(`Quadrant: ${trimLine(s.quadrant)}`);
+      if (s.tenderness.trim()) lines.push(`Tenderness: ${trimLine(s.tenderness)}`);
+      if (s.fixity.trim()) lines.push(`Fixity: ${trimLine(s.fixity)}`);
+      if (s.skinInvolvement.trim()) lines.push(`Skin involvement: ${trimLine(s.skinInvolvement)}`);
+      if (s.consistency.trim()) lines.push(`Consistency: ${trimLine(s.consistency)}`);
+      if (s.axillaryNodes) lines.push("Axillary nodes");
+      if (s.nippleAreolarComplex) lines.push("Nipple-areolar complex");
+      if (lines.length > 0) {
+        sub.push(`${label}: ${lines.join("; ")}`);
+      }
+    };
+    appendSide("Left breast", v.breast.left);
+    appendSide("Right breast", v.breast.right);
+    if (sub.length > 0) {
+      blocks.push(["Breast", ...sub.map((s) => `\u2022 ${s}`)].join("\n"));
+    }
+  }
+  if (v.regions.includes("thyroid")) {
+    const sub = [];
+    if (v.thyroid.size.trim()) sub.push(`Size: ${trimLine(v.thyroid.size)}`);
+    if (v.thyroid.mobileDeglutition) sub.push("Mobile with deglutition");
+    if (v.thyroid.nodules) sub.push("Nodules");
+    if (v.thyroid.cervicalNodes) sub.push("Cervical lymph nodes");
+    if (sub.length > 0) {
+      blocks.push(["Thyroid", ...sub.map((s) => `\u2022 ${s}`)].join("\n"));
+    }
+  }
+  if (v.regions.includes("anorectal")) {
+    const sub = [];
+    if (v.anorectal.inspection.trim())
+      sub.push(`Inspection: ${trimLine(v.anorectal.inspection)}`);
+    if (v.anorectal.dreDone) sub.push("DRE done");
+    if (v.anorectal.proctoscopyDone) sub.push("Proctoscopy done");
+    if (v.anorectal.notes.trim()) sub.push(`DRE / proctoscopy notes: ${trimLine(v.anorectal.notes)}`);
+    if (sub.length > 0) {
+      blocks.push(["Anorectal", ...sub.map((s) => `\u2022 ${s}`)].join("\n"));
+    }
+  }
+  if (v.regions.includes("limb")) {
+    const sub = [];
+    if (v.limb.dilatedVeins) sub.push("Dilated veins");
+    if (v.limb.ulcer) sub.push("Ulcer");
+    if (v.limb.oedema) sub.push("Oedema");
+    if (sub.length > 0) {
+      blocks.push(["Limb / varicose", ...sub.map((s) => `\u2022 ${s}`)].join("\n"));
+    }
+  }
+  return blocks.join("\n\n");
+}
+
+// src/core/urologyPathway.ts
+function defaultUrologySmartHistory() {
+  return {
+    socrates: {
+      site: "",
+      onset: "",
+      character: "",
+      radiation: "",
+      associated: "",
+      timing: "",
+      exacerbating: "",
+      severity: 0
+    },
+    ipss: {
+      incomplete: 0,
+      frequency: 0,
+      intermittency: 0,
+      urgency: 0,
+      weakStream: 0,
+      straining: 0,
+      nocturia: 0
+    },
+    ipssQoL: 0,
+    haematuria: {
+      present: false,
+      timing: "none",
+      painful: false,
+      clots: false
+    },
+    sexual: {
+      erectile: "none",
+      libido: "none",
+      ejaculation: "none",
+      infertilityMonths: 0
+    },
+    pastNotes: ""
+  };
+}
+function defaultUrologyExamination() {
+  return {
+    regions: [],
+    general: {
+      pallor: false,
+      oedema: false,
+      icterus: false,
+      lymphadenopathy: false
+    },
+    abdomen: {
+      distension: false,
+      scars: false,
+      mass: false,
+      kidneyPalpable: false,
+      bladderPalpable: false,
+      renalAngleTender: false,
+      bladderDull: false
+    },
+    gu: {
+      meatusAbnormal: false,
+      phimosis: false,
+      lesions: false,
+      scrotalSwelling: false,
+      transilluminant: false,
+      tenderTestis: false,
+      hydrocele: false,
+      varicocele: false,
+      suspiciousMass: false
+    },
+    dre: {
+      done: false,
+      sizeGrams: 0,
+      consistency: "",
+      medianSulcus: "",
+      tenderness: false
+    },
+    examinationNotes: ""
+  };
+}
+function defaultUrologyPathway() {
+  return {
+    stoneSizeMm: 0,
+    hydronephrosis: false,
+    prostateVolumeCc: 0,
+    psaNgMl: 0,
+    uroflowQmaxMlSec: 0,
+    risk: {
+      ckd: false,
+      diabetes: false,
+      anticoagulants: false,
+      activeInfection: false
+    }
+  };
+}
+function ipssItem(v) {
+  const n = Number(v);
+  if (!Number.isFinite(n)) return 0;
+  return Math.min(5, Math.max(0, Math.round(n)));
+}
+function urologyIpssSevenTotal(ipss) {
+  return ipss.incomplete + ipss.frequency + ipss.intermittency + ipss.urgency + ipss.weakStream + ipss.straining + ipss.nocturia;
+}
+function urologyIpssBand(total) {
+  if (total <= 7) return "Mild";
+  if (total <= 19) return "Moderate";
+  return "Severe";
+}
+function hopcMeaningfulStr(x) {
+  if (typeof x !== "string") return "";
+  const t = x.trim();
+  if (!t || t.toLowerCase() === "none") return "";
+  return t;
+}
+function hopcNonEmpty(lines) {
+  return lines.map((s) => (s ?? "").trim()).filter(Boolean);
+}
+function formatUrologySmartHistoryToSymptomsNarrative(safe, flags) {
+  const { showPain, showLUTS, showHaem, showSex } = flags;
+  const parts = [];
+  if (showPain) {
+    const s = safe.socrates;
+    const painLines = hopcNonEmpty([
+      s.site ? `Site: ${s.site}` : "",
+      s.onset ? `Onset: ${s.onset}` : "",
+      s.character ? `Character: ${s.character}` : "",
+      s.radiation ? `Radiation: ${s.radiation}` : "",
+      s.associated ? `Associated: ${s.associated}` : "",
+      s.timing ? `Timing: ${s.timing}` : "",
+      s.exacerbating ? `Exacerbating/relieving: ${s.exacerbating}` : "",
+      `Severity: ${s.severity}/10`
+    ]);
+    const hasNonDefaultPain = painLines.length > 1 || painLines.length === 1 && painLines[0] !== "Severity: 0/10";
+    if (hasNonDefaultPain) parts.push(`SOCRATES:
+${painLines.join("\n")}`);
+  }
+  if (showLUTS) {
+    const ip = safe.ipss;
+    const any = ip.incomplete || ip.frequency || ip.intermittency || ip.urgency || ip.weakStream || ip.straining || ip.nocturia || safe.ipssQoL;
+    if (any) {
+      const ipssTotal = urologyIpssSevenTotal(safe.ipss);
+      const ipssBandLabel = urologyIpssBand(ipssTotal);
+      parts.push(`IPSS: ${ipssTotal}/35 (${ipssBandLabel}) \xB7 QoL ${safe.ipssQoL}/6`);
+    }
+  }
+  if (showHaem) {
+    const h = safe.haematuria;
+    const timing = hopcMeaningfulStr(h.timing);
+    const haemLines = hopcNonEmpty([
+      h.present ? "Haematuria present" : "",
+      timing ? `Timing: ${timing}` : "",
+      h.painful ? "Painful" : "",
+      h.clots ? "Clots" : ""
+    ]);
+    if (haemLines.length) parts.push(`Haematuria:
+${haemLines.join("\n")}`);
+  }
+  if (showSex) {
+    const sx = safe.sexual;
+    const infertility = sx.infertilityMonths;
+    const sexLines = hopcNonEmpty([
+      hopcMeaningfulStr(sx.erectile) ? `Erectile function: ${hopcMeaningfulStr(sx.erectile)}` : "",
+      hopcMeaningfulStr(sx.libido) ? `Libido: ${hopcMeaningfulStr(sx.libido)}` : "",
+      hopcMeaningfulStr(sx.ejaculation) ? `Ejaculation: ${hopcMeaningfulStr(sx.ejaculation)}` : "",
+      Number.isFinite(infertility) && infertility > 0 ? `Infertility: ${infertility} months` : ""
+    ]);
+    if (sexLines.length) parts.push(`Sexual/reproductive:
+${sexLines.join("\n")}`);
+  }
+  return parts.join("\n\n").trim();
+}
+function formatUrologyExaminationToClinicalExamination(v) {
+  const sections = [];
+  const generalLabels = {
+    pallor: "Pallor (chronic dz)",
+    oedema: "Oedema (renal)",
+    icterus: "Icterus",
+    lymphadenopathy: "Lymphadenopathy"
+  };
+  const general = Object.keys(generalLabels).filter((k) => v.general[k]).map((k) => generalLabels[k]);
+  if (general.length) sections.push(`General: ${general.join(", ")}`);
+  const abdLabels = {
+    distension: "Distension",
+    scars: "Surgical scars",
+    mass: "Visible mass",
+    kidneyPalpable: "Kidney palpable",
+    bladderPalpable: "Bladder palpable",
+    renalAngleTender: "Renal angle tender",
+    bladderDull: "Bladder dullness (retention)"
+  };
+  const abd = Object.keys(abdLabels).filter((k) => v.abdomen[k]).map((k) => abdLabels[k]);
+  if (abd.length) sections.push(`Abdomen: ${abd.join(", ")}`);
+  const guLabels = {
+    meatusAbnormal: "Meatus abnormal (hypospadias?)",
+    phimosis: "Phimosis / paraphimosis",
+    lesions: "Penile lesions / ulcers",
+    scrotalSwelling: "Scrotal swelling",
+    transilluminant: "Transilluminant",
+    tenderTestis: "Tender testis",
+    hydrocele: "Hydrocele",
+    varicocele: "Varicocele",
+    suspiciousMass: "Suspicious mass"
+  };
+  const gu = Object.keys(guLabels).filter((k) => v.gu[k]).map((k) => guLabels[k]);
+  if (gu.length) sections.push(`GU: ${gu.join(", ")}`);
+  const dreBits = hopcNonEmpty([
+    v.dre.done ? "Performed" : "",
+    v.dre.sizeGrams > 0 ? `Size ~${v.dre.sizeGrams} g` : "",
+    v.dre.consistency ? `Consistency: ${v.dre.consistency}` : "",
+    v.dre.medianSulcus ? `Median sulcus: ${v.dre.medianSulcus}` : "",
+    v.dre.tenderness ? "Tenderness" : ""
+  ]);
+  if (dreBits.length) sections.push(`DRE: ${dreBits.join(", ")}`);
+  return sections.join("\n");
+}
+function str(x) {
+  return typeof x === "string" ? x : "";
+}
+function bool(x) {
+  return x === true;
+}
+function nonNegInt(x) {
+  const n = Number(x);
+  if (!Number.isFinite(n)) return 0;
+  return Math.max(0, Math.round(n));
+}
+function normalizeUrologySmartHistory(raw) {
+  const base = defaultUrologySmartHistory();
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return base;
+  const r = raw;
+  const soc = r.socrates && typeof r.socrates === "object" && !Array.isArray(r.socrates) ? r.socrates : {};
+  const socObj = soc;
+  const sev = Number(socObj.severity);
+  const socrates = {
+    site: str(socObj.site),
+    onset: str(socObj.onset),
+    character: str(socObj.character),
+    radiation: str(socObj.radiation),
+    associated: str(socObj.associated),
+    timing: str(socObj.timing),
+    exacerbating: str(socObj.exacerbating),
+    severity: Number.isFinite(sev) ? Math.min(10, Math.max(0, Math.round(sev))) : 0
+  };
+  const ipRaw = r.ipss && typeof r.ipss === "object" && !Array.isArray(r.ipss) ? r.ipss : {};
+  const ip = ipRaw;
+  const ipss = {
+    incomplete: ipssItem(ip.incomplete),
+    frequency: ipssItem(ip.frequency),
+    intermittency: ipssItem(ip.intermittency),
+    urgency: ipssItem(ip.urgency),
+    weakStream: ipssItem(ip.weakStream ?? ip.weak_stream),
+    straining: ipssItem(ip.straining),
+    nocturia: ipssItem(ip.nocturia)
+  };
+  const qolRaw = Number(r.ipssQoL);
+  const ipssQoL = Number.isFinite(qolRaw) ? Math.min(6, Math.max(0, Math.round(qolRaw))) : 0;
+  const haRaw = r.haematuria && typeof r.haematuria === "object" && !Array.isArray(r.haematuria) ? r.haematuria : {};
+  const ha = haRaw;
+  const haematuria = {
+    present: bool(ha.present),
+    timing: str(ha.timing) || "none",
+    painful: bool(ha.painful),
+    clots: bool(ha.clots)
+  };
+  const sxRaw = r.sexual && typeof r.sexual === "object" && !Array.isArray(r.sexual) ? r.sexual : {};
+  const sx = sxRaw;
+  const infertilityMonths = nonNegInt(sx.infertilityMonths);
+  const sexual = {
+    erectile: str(sx.erectile) || "none",
+    libido: str(sx.libido) || "none",
+    ejaculation: str(sx.ejaculation) || "none",
+    infertilityMonths
+  };
+  const pastNotes = str(r.pastNotes);
+  return {
+    socrates,
+    ipss,
+    ipssQoL,
+    haematuria,
+    sexual,
+    pastNotes
+  };
+}
+function dreSelectStr(x) {
+  const t = str(x).trim();
+  if (!t || t.toLowerCase() === "none") return "";
+  return t;
+}
+function normalizeUrologyExamination(raw) {
+  const base = defaultUrologyExamination();
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return base;
+  const r = raw;
+  const regions = Array.isArray(r.regions) ? r.regions.filter((x) => typeof x === "string") : [];
+  const g = r.general && typeof r.general === "object" && !Array.isArray(r.general) ? r.general : {};
+  const gObj = g;
+  const general = {
+    pallor: bool(gObj.pallor),
+    oedema: bool(gObj.oedema),
+    icterus: bool(gObj.icterus),
+    lymphadenopathy: bool(gObj.lymphadenopathy)
+  };
+  const ab = r.abdomen && typeof r.abdomen === "object" && !Array.isArray(r.abdomen) ? r.abdomen : {};
+  const abObj = ab;
+  const abdomen = {
+    distension: bool(abObj.distension),
+    scars: bool(abObj.scars),
+    mass: bool(abObj.mass),
+    kidneyPalpable: bool(abObj.kidneyPalpable),
+    bladderPalpable: bool(abObj.bladderPalpable),
+    renalAngleTender: bool(abObj.renalAngleTender),
+    bladderDull: bool(abObj.bladderDull)
+  };
+  const guRaw = r.gu && typeof r.gu === "object" && !Array.isArray(r.gu) ? r.gu : {};
+  const guObj = guRaw;
+  const gu = {
+    meatusAbnormal: bool(guObj.meatusAbnormal),
+    phimosis: bool(guObj.phimosis),
+    lesions: bool(guObj.lesions),
+    scrotalSwelling: bool(guObj.scrotalSwelling),
+    transilluminant: bool(guObj.transilluminant),
+    tenderTestis: bool(guObj.tenderTestis),
+    hydrocele: bool(guObj.hydrocele),
+    varicocele: bool(guObj.varicocele),
+    suspiciousMass: bool(guObj.suspiciousMass)
+  };
+  const dr = r.dre && typeof r.dre === "object" && !Array.isArray(r.dre) ? r.dre : {};
+  const drObj = dr;
+  const sizeG = Number(drObj.sizeGrams);
+  const dre = {
+    done: bool(drObj.done),
+    sizeGrams: Number.isFinite(sizeG) && sizeG >= 0 ? Math.round(sizeG) : 0,
+    consistency: dreSelectStr(drObj.consistency),
+    medianSulcus: dreSelectStr(drObj.medianSulcus),
+    tenderness: bool(drObj.tenderness)
+  };
+  const examinationNotes = str(r.examinationNotes);
+  return {
+    regions,
+    general,
+    abdomen,
+    gu,
+    dre,
+    examinationNotes
+  };
+}
+function normalizeUrologyPathway(raw) {
+  const base = defaultUrologyPathway();
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return base;
+  const r = raw;
+  const stoneSizeMm = nonNegInt(r.stoneSizeMm);
+  const hydronephrosis = bool(r.hydronephrosis);
+  const prostateVolumeCc = Math.max(0, Number(r.prostateVolumeCc) || 0);
+  const psaNgMl = Math.max(0, Number(r.psaNgMl) || 0);
+  const uroflowQmaxMlSec = Math.max(0, Number(r.uroflowQmaxMlSec) || 0);
+  const riskRaw = r.risk && typeof r.risk === "object" && !Array.isArray(r.risk) ? r.risk : {};
+  const rk = riskRaw;
+  const risk = {
+    ckd: bool(rk.ckd),
+    diabetes: bool(rk.diabetes),
+    anticoagulants: bool(rk.anticoagulants),
+    activeInfection: bool(rk.activeInfection)
+  };
+  return {
+    stoneSizeMm,
+    hydronephrosis,
+    prostateVolumeCc,
+    psaNgMl,
+    uroflowQmaxMlSec,
+    risk
+  };
+}
+
+// src/core/painScaleFlags.ts
+var UPT_VALUES = ["", "Positive", "Negative", "Not done"];
+function isUpt(x) {
+  return typeof x === "string" && UPT_VALUES.includes(x);
+}
+function normalizePainScaleFlags(raw, bounds) {
+  const min = bounds?.min ?? 0;
+  const max = bounds?.max ?? 10;
+  let pain = min;
+  let flags = [];
+  let bp = "";
+  let upt = "";
+  if (raw && typeof raw === "object" && !Array.isArray(raw)) {
+    const o = raw;
+    const p = Number(o.pain);
+    if (Number.isFinite(p)) pain = Math.min(max, Math.max(min, p));
+    if (Array.isArray(o.flags)) {
+      flags = o.flags.filter((x) => typeof x === "string");
+    }
+    if (typeof o.bp === "string") bp = o.bp;
+    if (isUpt(o.upt)) upt = o.upt;
+  }
+  return { pain, flags, bp, upt };
+}
+
+// src/core/persistence/index.ts
+var NO_OP_PROVIDER = {
+  save: async () => {
+  },
+  load: async () => null,
+  clear: async () => {
+  }
+};
+
+// src/core/prefill.ts
+function applyPrefill(currentValues, fields, prefilledData = {}) {
+  const newValues = { ...currentValues };
+  fields.forEach((field) => {
+    if (field.prefill?.value !== void 0) {
+      newValues[field.id] = field.prefill.value;
+      return;
+    }
+    if (prefilledData[field.id] !== void 0) {
+      newValues[field.id] = prefilledData[field.id];
+      return;
+    }
+  });
+  return newValues;
+}
+
+// src/core/store.ts
+var FormStore = class {
+  state;
+  schema;
+  fieldMap;
+  listeners = /* @__PURE__ */ new Set();
+  persistence;
+  prefillData = {};
+  config;
+  // Widget-owned errors that schema validation cannot express (e.g. "OTP not sent yet").
+  // Merged on top of validateForm output in evaluate().
+  externalErrors = {};
+  // Cache for debounce
+  saveTimeout = null;
+  draftCallbackTimeout = null;
+  constructor(schema, config = {}) {
+    this.schema = schema;
+    this.config = config;
+    this.persistence = config.persistence || NO_OP_PROVIDER;
+    this.prefillData = config.prefillData || {};
+    this.fieldMap = {};
+    schema.fields.forEach((f) => {
+      this.fieldMap[f.id] = f;
+    });
+    const initialWorkflowState = schema.workflow?.states?.[0] || "DRAFT";
+    this.state = {
+      values: {},
+      errors: {},
+      touched: {},
+      visibility: {},
+      disabled: {},
+      workflowState: initialWorkflowState,
+      isValid: true,
+      isSubmitting: false,
+      submitAttempted: false,
+      pendingUploads: 0
+    };
+    this.initializeDefaults();
+    this.evaluate();
+  }
+  initializeDefaults() {
+    const values = {};
+    this.schema.fields.forEach((field) => {
+      if (field.type === "static_text") return;
+      if (field.defaultValue !== void 0) {
+        values[field.id] = field.defaultValue;
+      } else {
+        if (field.type === "repeatable") values[field.id] = [];
+        else if (field.type === "checkbox" || field.type === "multiselect") values[field.id] = [];
+        else if (field.type === "smart_textarea") values[field.id] = { text: "", extractedKeywords: [] };
+        else if (field.type === "suggestion_textarea" || field.type === "complaint_chips") values[field.id] = "";
+        else if (field.type === "lens_assessment")
+          values[field.id] = {
+            notes: "",
+            assessmentKey: void 0,
+            locs: {
+              OD: { NO: 0, NC: 0, C: 0, PSC: 0 },
+              OS: { NO: 0, NC: 0, C: 0, PSC: 0 }
+            }
+          };
+        else if (field.type === "functional_impairment_score")
+          values[field.id] = {
+            reading: 0,
+            nightDriving: 0,
+            glare: 0,
+            occupation: 0,
+            adl: 0
+          };
+        else if (field.type === "biometry_iol_workup")
+          values[field.id] = {
+            axialLengthOD: "",
+            axialLengthOS: "",
+            k1k2AxisOD: "",
+            k1k2AxisOS: "",
+            anteriorChamberDepthOD: "",
+            anteriorChamberDepthOS: "",
+            iolPowerOD: "",
+            iolPowerOS: "",
+            targetRefractionOD: "",
+            targetRefractionOS: "",
+            formula: "SRK/T",
+            method: "optical_biometry",
+            cornealTopoUploaded: false,
+            specularMicroscopyDone: false,
+            endothelialCount: ""
+          };
+        else if (field.type === "surgical_risk_flags")
+          values[field.id] = { OD: [], OS: [] };
+        else if (field.type === "toggle") values[field.id] = false;
+        else if (field.type === "slider") {
+          const s = field;
+          values[field.id] = s.defaultValue ?? s.min ?? 0;
+        } else if (field.type === "general_surgery_smart_history") {
+          values[field.id] = field.defaultValue ?? defaultGeneralSurgerySmartHistory();
+        } else if (field.type === "general_surgery_examination") {
+          values[field.id] = field.defaultValue ?? defaultGeneralSurgeryExamination();
+        } else if (field.type === "general_surgery_grading") {
+          values[field.id] = field.defaultValue ?? defaultGeneralSurgeryGrading();
+        } else if (field.type === "urology_smart_history") {
+          values[field.id] = field.defaultValue ?? defaultUrologySmartHistory();
+        } else if (field.type === "urology_examination") {
+          values[field.id] = field.defaultValue ?? defaultUrologyExamination();
+        } else if (field.type === "urology_pathway") {
+          values[field.id] = field.defaultValue ?? defaultUrologyPathway();
+        } else if (field.type === "pain_scale_flags") {
+          const f = field;
+          values[field.id] = normalizePainScaleFlags(
+            f.defaultValue ?? { pain: f.min ?? 0, flags: [] },
+            { min: f.min, max: f.max }
+          );
+        } else values[field.id] = null;
+      }
+    });
+    this.state.values = values;
+  }
+  // --- State Access ---
+  getState() {
+    return this.state;
+  }
+  getFieldState(fieldId) {
+    return {
+      value: this.state.values[fieldId],
+      error: this.state.errors[fieldId],
+      touched: this.state.touched[fieldId],
+      visible: this.state.visibility[fieldId] ?? true,
+      disabled: this.state.disabled[fieldId] ?? false
+    };
+  }
+  getSchema() {
+    return this.schema;
+  }
+  getConfig() {
+    return this.config;
+  }
+  getFieldDef(fieldId) {
+    return this.fieldMap[fieldId];
+  }
+  getVoice() {
+    return this.config.voice;
+  }
+  hasPersistence() {
+    return this.persistence !== NO_OP_PROVIDER;
+  }
+  // --- Actions ---
+  setValue(fieldId, value) {
+    if (this.state.values[fieldId] === value) return;
+    this.state.values = { ...this.state.values, [fieldId]: value };
+    this.state.touched = { ...this.state.touched, [fieldId]: true };
+    this.checkEvents(fieldId, "onValueChange", value);
+    this.evaluate();
+    this.notify();
+    this.scheduleDraftCallback();
+    if (!this.config.onDraftChange) {
+      this.scheduleSave();
+    }
+  }
+  /**
+   * Set multiple values at once (e.g. from AI analysis). Only updates keys that
+   * exist in the schema. Runs evaluate/notify/save once.
+   * @param partial Map of fieldId -> value
+   * @param options.touch If false, do not mark fields as touched (e.g. for AI-suggested values)
+   */
+  setValues(partial, options) {
+    const touch = options?.touch !== false;
+    let changed = false;
+    const newValues = { ...this.state.values };
+    const newTouched = { ...this.state.touched };
+    for (const [fieldId, value] of Object.entries(partial)) {
+      if (!this.fieldMap[fieldId]) continue;
+      if (newValues[fieldId] === value) continue;
+      newValues[fieldId] = value;
+      if (touch) newTouched[fieldId] = true;
+      changed = true;
+    }
+    if (!changed) return;
+    this.state.values = newValues;
+    this.state.touched = newTouched;
+    this.evaluate();
+    this.notify();
+    this.scheduleSave();
+  }
+  /**
+   * Let a widget report an error that schema validation cannot express
+   * (e.g. "Send OTP to continue" until the API call succeeds).
+   * Pass `null` to clear a previously set external error.
+   */
+  setExternalError(fieldId, message) {
+    if ((this.externalErrors[fieldId] ?? null) === message) return;
+    this.externalErrors = { ...this.externalErrors, [fieldId]: message };
+    this.evaluate();
+    this.notify();
+  }
+  setTouched(fieldId) {
+    if (this.state.touched[fieldId]) return;
+    this.state.touched = { ...this.state.touched, [fieldId]: true };
+    this.checkEvents(fieldId, "onBlur", this.state.values[fieldId]);
+    this.evaluate();
+    this.notify();
+  }
+  setRole(role) {
+    this.config.role = role;
+    this.evaluate();
+    this.notify();
+  }
+  // --- Lifecycle ---
+  async load() {
+    const saved = await this.persistence.load(this.schema.id);
+    let mergedValues = { ...this.state.values };
+    let workflowState = this.state.workflowState;
+    if (saved) {
+      console.log("Loaded draft:", saved);
+      mergedValues = { ...mergedValues, ...saved.values };
+      workflowState = saved.meta.workflowState || workflowState;
+    }
+    mergedValues = applyPrefill(mergedValues, this.schema.fields, this.prefillData);
+    this.state.values = mergedValues;
+    this.state.workflowState = workflowState;
+    this.evaluate();
+    this.notify();
+  }
+  scheduleSave() {
+    if (this.saveTimeout) clearTimeout(this.saveTimeout);
+    this.saveTimeout = setTimeout(() => {
+      this.save();
+    }, 1e3);
+  }
+  scheduleDraftCallback() {
+    if (!this.config.onDraftChange) return;
+    if (this.draftCallbackTimeout) {
+      clearTimeout(this.draftCallbackTimeout);
+    }
+    this.draftCallbackTimeout = setTimeout(() => {
+      const payload = {
+        // For consumer callbacks, send values in the same
+        // serialized shape used for outbound submissions so
+        // media/signature fields are wrapped consistently.
+        values: this.serializeValuesForSubmission(this.state.values),
+        meta: {
+          updatedAt: Date.now(),
+          workflowState: this.state.workflowState,
+          version: this.schema.version
+        }
+      };
+      this.config.onDraftChange?.(payload);
+    }, 5e3);
+  }
+  async save() {
+    const payload = {
+      values: this.state.values,
+      meta: {
+        updatedAt: Date.now(),
+        workflowState: this.state.workflowState,
+        version: this.schema.version
+      }
+    };
+    await this.persistence.save(this.schema.id, payload);
+    this.emit("DRAFT_SAVED", payload);
+  }
+  /**
+   * Prepare values for outbound submission to the backend.
+   * For media-related fields, wrap the raw S3 key in a typed object so the
+   * backend can recognise which fields need presigned GET URLs.
+   *
+   * Example:
+   *   "patient_signature": "forms/media-uploads/.../signature.svg"
+   * becomes:
+   *   "patient_signature": {
+   *     _type: "s3_key",
+   *     value: "forms/media-uploads/.../signature.svg"
+   *   }
+   */
+  getSerializedValuesForSubmission() {
+    return this.serializeValuesForSubmission(this.state.values);
+  }
+  /**
+   * Raw form values as stored internally, without any serialization or
+   * transformation. Useful when consumers need access to richer structures
+   * (e.g. smart_textarea keyword metadata) alongside the flattened values
+   * returned by getSerializedValuesForSubmission.
+   */
+  getRawValues() {
+    return { ...this.state.values };
+  }
+  serializeValuesForSubmission(values) {
+    const result = { ...values };
+    this.schema.fields.forEach((field) => {
+      if (field.type === "static_text") {
+        delete result[field.id];
+        return;
+      }
+      if (field.type === "smart_textarea") {
+        const raw = values[field.id];
+        result[field.id] = raw?.text ?? null;
+        return;
+      }
+      if (field.type === "diagnosis_textarea") {
+        const raw = values[field.id];
+        result[field.id] = typeof raw === "string" ? raw : raw && typeof raw === "object" ? raw.text ?? null : null;
+        return;
+      }
+      if (field.type === "ophthal_diagnosis") {
+        const raw = values[field.id];
+        const formatEye = (eyeData, eyeLabel) => {
+          if (!eyeData || typeof eyeData !== "object") return "";
+          const entries = Object.entries(eyeData).filter(([, value]) => typeof value === "string" && value.trim()).map(([key, value]) => `${key}: ${value.trim()}`);
+          if (entries.length === 0) return "";
+          return [eyeLabel, ...entries].join("\n");
+        };
+        const rightEyeText = formatEye(
+          raw?.right_eye ?? raw?.rightEye,
+          "Right Eye"
+        );
+        const leftEyeText = formatEye(
+          raw?.left_eye ?? raw?.leftEye,
+          "Left Eye"
+        );
+        const parts = [rightEyeText, leftEyeText].filter(Boolean);
+        result[field.id] = parts.length > 0 ? parts.join("\n\n") : null;
+        return;
+      }
+      if (field.type === "otp_input") {
+        const raw = values[field.id];
+        if (typeof raw === "string") {
+          result[field.id] = raw;
+          return;
+        }
+        if (raw && typeof raw === "object" && !Array.isArray(raw) && raw.verified === true) {
+          const code = raw.code;
+          result[field.id] = typeof code === "string" ? code : null;
+          return;
+        }
+        result[field.id] = null;
+        return;
+      }
+      if (field.type === "image_upload" || field.type === "media_upload" || field.type === "signature" || field.type === "file_upload") {
+        const raw = values[field.id];
+        if (raw === void 0 || raw === null || raw === "") {
+          return;
+        }
+        const wrapKey = (key2) => {
+          if (typeof key2 !== "string" || !key2) return null;
+          return { _type: "s3_key", value: key2 };
+        };
+        if (Array.isArray(raw)) {
+          const wrapped2 = raw.map(
+            (item) => typeof item === "string" ? wrapKey(item) : wrapKey(item.s3_key ?? item.value)
+          ).filter(Boolean);
+          if (wrapped2.length > 0) {
+            result[field.id] = wrapped2;
+          }
+          return;
+        }
+        const key = typeof raw === "string" ? raw : raw.s3_key ?? raw.value ?? null;
+        const wrapped = wrapKey(key);
+        if (wrapped) {
+          result[field.id] = wrapped;
+        }
+      }
+    });
+    return result;
+  }
+  // --- Core Logic ---
+  evaluate() {
+    if (this.schema.computations) {
+      this.schema.computations.forEach((comp) => {
+        if (comp.type === "sum") {
+          const sum = comp.fields.reduce((acc, fieldId) => {
+            const raw = this.state.values[fieldId];
+            const fieldDef = this.fieldMap[fieldId];
+            const options = fieldDef?.type === "select" || fieldDef?.type === "multiselect" || fieldDef?.type === "radio" || fieldDef?.type === "checkbox" ? fieldDef.options : void 0;
+            const hasScoreOptions = options?.some((o) => o.score !== void 0);
+            let val;
+            if (hasScoreOptions && options) {
+              const selected = fieldDef?.type === "multiselect" || fieldDef?.type === "checkbox" ? (Array.isArray(raw) ? raw : [raw]).filter(Boolean) : [raw];
+              val = selected.reduce((s, v) => {
+                const opt = options.find((o) => o.value === v || String(o.value) === String(v));
+                return s + (opt && "score" in opt && typeof opt.score === "number" ? opt.score : 0);
+              }, 0);
+            } else {
+              val = Number(raw) || 0;
+            }
+            return acc + val;
+          }, 0);
+          if (this.state.values[comp.target] !== sum) {
+            this.state.values[comp.target] = sum;
+          }
+        } else if (comp.type === "score") {
+          const val = Number(this.state.values[comp.source]);
+          if (this.state.values[comp.source] !== void 0 && this.state.values[comp.source] !== null && this.state.values[comp.source] !== "") {
+            let score = 0;
+            const matched = comp.ranges.find((r) => {
+              const min = r.min ?? -Infinity;
+              const max = r.max ?? Infinity;
+              return val >= min && val <= max;
+            });
+            if (matched) {
+              score = matched.value;
+            }
+            if (this.state.values[comp.target] !== score) {
+              this.state.values[comp.target] = score;
+            }
+          } else {
+            if (this.state.values[comp.target] !== 0) {
+              this.state.values[comp.target] = 0;
+            }
+          }
+        } else if (comp.type === "formula") {
+          const evalExpr = (expr) => {
+            if (expr.type === "field") {
+              return Number(this.state.values[expr.field]) || 0;
+            }
+            if (expr.type === "number") {
+              return expr.value;
+            }
+            const left = evalExpr(expr.left);
+            const right = evalExpr(expr.right);
+            switch (expr.op) {
+              case "+":
+                return left + right;
+              case "-":
+                return left - right;
+              case "*":
+                return left * right;
+              case "/":
+                return right === 0 ? 0 : left / right;
+              case "**":
+                return Math.pow(left, right);
+              default:
+                return 0;
+            }
+          };
+          const result = evalExpr(comp.expression);
+          const value = Number.isFinite(result) ? Math.round(result * 10) / 10 : "";
+          if (this.state.values[comp.target] !== value) {
+            this.state.values[comp.target] = value;
+          }
+        }
+      });
+    }
+    const ruleResult = evaluateRules(this.state.values, this.schema.rules || [], this.fieldMap);
+    this.state.visibility = ruleResult.visibility;
+    this.state.disabled = ruleResult.disabled;
+    if (this.config.role) {
+      this.schema.fields.forEach((field) => {
+        if (field.permissions && field.permissions[this.config.role]) {
+          const perm = field.permissions[this.config.role];
+          if (perm === "hide") this.state.visibility[field.id] = false;
+          if (perm === "view") this.state.disabled[field.id] = true;
+        }
+      });
+    }
+    const effectiveFields = {};
+    Object.keys(this.fieldMap).forEach((key) => {
+      effectiveFields[key] = {
+        ...this.fieldMap[key],
+        required: ruleResult.required[key] ?? this.fieldMap[key].required,
+        hidden: !this.state.visibility[key],
+        // Inject current visibility
+        disabled: this.state.disabled[key]
+      };
+    });
+    const errors = validateForm(this.state.values, effectiveFields);
+    const merged = { ...errors };
+    for (const [id, msg] of Object.entries(this.externalErrors)) {
+      if (msg) merged[id] = msg;
+    }
+    this.state.errors = merged;
+    this.state.isValid = Object.keys(merged).length === 0;
+  }
+  // --- Workflow ---
+  getAvailableTransitions() {
+    const transitions = this.schema.workflow?.transitions || [];
+    const role = this.config.role;
+    return transitions.filter(
+      (t) => t.from === this.state.workflowState && (!role || t.allowedRoles.includes(role))
+    );
+  }
+  transition(toState) {
+    const t = this.getAvailableTransitions().find((tr) => tr.to === toState);
+    if (!t) throw new Error(`Transition from ${this.state.workflowState} to ${toState} not allowed`);
+    this.state.workflowState = toState;
+    if (t.webhookKey) {
+      this.emit("FINALISE_REQUESTED", { webhookKey: t.webhookKey, values: this.state.values });
+    }
+    this.save();
+    this.notify();
+  }
+  // --- Events ---
+  checkEvents(fieldId, trigger, value) {
+    const field = this.fieldMap[fieldId];
+    if (!field?.events) return;
+    field.events.forEach((evt) => {
+      if (evt.trigger === trigger) {
+        let match = true;
+        if (evt.condition) {
+          if (evt.condition.op === ">") match = Number(value) > Number(evt.condition.value);
+        }
+        if (match) {
+          this.emit(evt.emit, { fieldId, value });
+        }
+      }
+    });
+  }
+  emit(event, payload) {
+    let finalPayload = payload;
+    if (event === "FINALISE_REQUESTED" || event === "DRAFT_SAVED") {
+      if (payload && typeof payload === "object" && "values" in payload) {
+        finalPayload = {
+          ...payload,
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          values: this.serializeValuesForSubmission(
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            payload.values ?? {}
+          )
+        };
+      }
+    }
+    console.log("[Formanitor Event]", event, finalPayload);
+    if (this.config.onEvent) {
+      this.config.onEvent(event, finalPayload);
+    }
+  }
+  /**
+   * Update mutable config properties (callbacks, role) without recreating
+   * the store.  This allows the host app to pass fresh closures (e.g. an
+   * upload handler whose auth token was initially undefined) after the
+   * initial render.
+   */
+  updateConfig(next) {
+    let needsReeval = false;
+    if (next.onUpload !== void 0) this.config.onUpload = next.onUpload;
+    if (next.onFileUpload !== void 0)
+      this.config.onFileUpload = next.onFileUpload;
+    if (next.onEvent !== void 0) this.config.onEvent = next.onEvent;
+    if (next.onDraftChange !== void 0) this.config.onDraftChange = next.onDraftChange;
+    if (next.voice !== void 0) this.config.voice = next.voice;
+    if (next.role !== void 0 && next.role !== this.config.role) {
+      this.config.role = next.role;
+      needsReeval = true;
+    }
+    if (next.prefillData !== void 0 && next.prefillData !== this.prefillData) {
+      this.prefillData = next.prefillData;
+      this.state.values = applyPrefill(this.state.values, this.schema.fields, this.prefillData);
+      needsReeval = true;
+    }
+    if (needsReeval) {
+      this.evaluate();
+      this.notify();
+    }
+  }
+  getUploadHandler() {
+    return this.config.onUpload;
+  }
+  /** Resolved handler for `file_upload` widgets: `onFileUpload` ?? `onUpload`. */
+  getFileUploadHandler() {
+    return this.config.onFileUpload ?? this.config.onUpload;
+  }
+  preSubmitHandlers = /* @__PURE__ */ new Map();
+  registerPreSubmitHandler(fieldId, fn) {
+    this.preSubmitHandlers.set(fieldId, fn);
+  }
+  unregisterPreSubmitHandler(fieldId) {
+    this.preSubmitHandlers.delete(fieldId);
+  }
+  /**
+   * Runs all registered pre-submit handlers in parallel.
+   * Call this before getSerializedValuesForSubmission() to ensure any
+   * unconfirmed signatures (or similar) are uploaded first.
+   */
+  async flushPendingUploads() {
+    const handlers = Array.from(this.preSubmitHandlers.values());
+    await Promise.all(handlers.map((fn) => fn()));
+  }
+  incrementPendingUploads() {
+    this.state.pendingUploads = (this.state.pendingUploads ?? 0) + 1;
+    this.notify();
+  }
+  decrementPendingUploads() {
+    this.state.pendingUploads = Math.max(0, (this.state.pendingUploads ?? 0) - 1);
+    this.notify();
+  }
+  // Mark that a submit attempt has been made so UI can decide when to show errors
+  markSubmitAttempted() {
+    if (!this.state.submitAttempted) {
+      this.state.submitAttempted = true;
+      this.notify();
+    }
+  }
+  // --- Subscriptions ---
+  subscribe(listener) {
+    console.log("[FormStore] subscribe: adding listener. Total before add:", this.listeners.size);
+    this.listeners.add(listener);
+    return () => {
+      console.log("[FormStore] unsubscribe: removing listener. Total before remove:", this.listeners.size);
+      this.listeners.delete(listener);
+      console.log("[FormStore] unsubscribe: removed listener. Total after remove:", this.listeners.size);
+    };
+  }
+  notify() {
+    console.log("[FormStore] notify: listener count", this.listeners.size, "state snapshot", {
+      workflowState: this.state.workflowState,
+      isValid: this.state.isValid
+    });
+    this.listeners.forEach((l) => l(this.state));
+  }
+};
+var VoiceContext = createContext({
+  activeFieldId: null,
+  setActiveFieldId: () => {
+  }
+});
+function useVoiceContext() {
+  return useContext(VoiceContext);
+}
+function VoiceContextProvider({ children }) {
+  const [activeFieldId, setActiveFieldIdState] = useState(null);
+  const setActiveFieldId = useCallback((id) => {
+    setActiveFieldIdState(id);
+  }, []);
+  return /* @__PURE__ */ jsx(VoiceContext.Provider, { value: { activeFieldId, setActiveFieldId }, children });
+}
+var FormContext = createContext(null);
+var emptyFrequentItems = {
+  medications: [],
+  investigations: [],
+  procedures: []
+};
+var FrequentItemsContext = createContext(emptyFrequentItems);
+var PackagesContext = createContext([]);
+var FieldHandlersContext = createContext({});
+function useFieldHandlers(fieldId) {
+  const map = useContext(FieldHandlersContext);
+  return map[fieldId] ?? { onSearch: async () => [], recentlyUsed: [] };
+}
+function useFrequentItems() {
+  return useContext(FrequentItemsContext);
+}
+function usePackages() {
+  return useContext(PackagesContext);
+}
+var FormProvider = ({
+  schema,
+  config,
+  fieldHandlers,
+  frequentItems,
+  packages,
+  children
+}) => {
+  const storeRef = useRef(null);
+  if (!storeRef.current) {
+    storeRef.current = new FormStore(schema, config);
+  }
+  useEffect(() => {
+    if (storeRef.current && config) {
+      storeRef.current.updateConfig(config);
+    }
+  });
+  useEffect(() => {
+    storeRef.current?.load();
+  }, []);
+  const frequentItemsValue = frequentItems ?? emptyFrequentItems;
+  return /* @__PURE__ */ jsx(FormContext.Provider, { value: storeRef.current, children: /* @__PURE__ */ jsx(FieldHandlersContext.Provider, { value: fieldHandlers ?? {}, children: /* @__PURE__ */ jsx(FrequentItemsContext.Provider, { value: frequentItemsValue, children: /* @__PURE__ */ jsx(PackagesContext.Provider, { value: packages ?? [], children: /* @__PURE__ */ jsx(VoiceContextProvider, { children }) }) }) }) });
+};
+function useFormStore() {
+  const context = useContext(FormContext);
+  if (!context) {
+    throw new Error("useFormStore must be used within a FormProvider");
+  }
+  return context;
+}
+function useField(fieldId) {
+  const store = useFormStore();
+  const [fieldState, setFieldState] = useState(store.getFieldState(fieldId));
+  useEffect(() => {
+    const unsubscribe = store.subscribe(() => {
+      const newState = store.getFieldState(fieldId);
+      setFieldState((prev) => {
+        if (prev.value === newState.value && prev.error === newState.error && prev.touched === newState.touched && prev.visible === newState.visible && prev.disabled === newState.disabled) {
+          return prev;
+        }
+        return newState;
+      });
+    });
+    return unsubscribe;
+  }, [store, fieldId]);
+  const setValue = (val) => store.setValue(fieldId, val);
+  const setTouched = () => store.setTouched(fieldId);
+  const fieldDef = store.getFieldDef(fieldId);
+  return {
+    ...fieldState,
+    fieldDef,
+    setValue,
+    setTouched
+  };
+}
+
+export { ALL_GS_CONDITIONS, EMAIL_REGEX, FormProvider, FormStore, GS_CONDITION_LABELS, GS_GRADE_DESCRIPTIONS, composeProseAndChips, evaluateRules, formatGeneralSurgeryExaminationToNarrative, formatGeneralSurgerySmartHistoryToNarrative, formatUrologyExaminationToClinicalExamination, formatUrologySmartHistoryToSymptomsNarrative, getSuggestionTokensFromText, gsGradingRowVisible, normalizeGeneralSurgeryExamination, normalizeGeneralSurgeryGrading, normalizeGeneralSurgerySmartHistory, normalizePainScaleFlags, normalizeUrologyExamination, normalizeUrologyPathway, normalizeUrologySmartHistory, parseProseAndChipTokens, toggleSuggestionTokenInText, urologyIpssBand, urologyIpssSevenTotal, useField, useFieldHandlers, useFormStore, useFrequentItems, usePackages, useVoiceContext, validateField, validateForm };
+//# sourceMappingURL=chunk-ZGPHTPAN.mjs.map
+//# sourceMappingURL=chunk-ZGPHTPAN.mjs.map