jupiter-dynamic-forms 1.20.2 → 1.20.4

package/dist/index.mjs

@@ -1668,7 +1668,8 @@ const form$1 = {
   download: "Download",
   cancelValidation: "Cancel Validation",
   lastValidationResults: "Last Validation Results",
-  validationInProgress: "Validation In Progress"
+  validationInProgress: "Validation In Progress",
+  quickValidate: "Quick Validate"
 };
 const filter$1 = {
   selectRoles: "Select Roles",
@@ -1817,6 +1818,15 @@ const calculationWarning$1 = {
   added: "Added",
   subtracted: "Subtracted (opposite balance)"
 };
+const formulaValidation$1 = {
+  dialogTitle: "Formula check results",
+  allPassed: "All formula checks passed",
+  summaryCount: "{{failed}} of {{total}} checks failed",
+  summaryCountBreakdown: "{{warnings}} warnings, {{errors}} errors",
+  severityWarning: "Warning",
+  severityError: "Error",
+  close: "Close"
+};
 const enTranslations = {
   conceptInfo: conceptInfo$1,
   form: form$1,
@@ -1828,7 +1838,8 @@ const enTranslations = {
   validation: validation$1,
   xbrlValidation: xbrlValidation$1,
   error: error$1,
-  calculationWarning: calculationWarning$1
+  calculationWarning: calculationWarning$1,
+  formulaValidation: formulaValidation$1
 };
 const conceptInfo = {
   title: "Conceptinformatie",
@@ -1863,7 +1874,8 @@ const form = {
   download: "Downloaden",
   cancelValidation: "Validatie annuleren",
   lastValidationResults: "Laatste validatieresultaten",
-  validationInProgress: "Validatie bezig"
+  validationInProgress: "Validatie bezig",
+  quickValidate: "Snel valideren"
 };
 const filter = {
   selectRoles: "Rollen selecteren",
@@ -2012,6 +2024,15 @@ const calculationWarning = {
   added: "Opgeteld",
   subtracted: "Afgetrokken (tegengestelde balans)"
 };
+const formulaValidation = {
+  dialogTitle: "Resultaten formulecontrole",
+  allPassed: "Alle formulecontroles geslaagd",
+  summaryCount: "{{failed}} van {{total}} controles mislukt",
+  summaryCountBreakdown: "{{warnings}} waarschuwingen, {{errors}} fouten",
+  severityWarning: "Waarschuwing",
+  severityError: "Fout",
+  close: "Sluiten"
+};
 const nlTranslations = {
   conceptInfo,
   form,
@@ -2023,7 +2044,8 @@ const nlTranslations = {
   validation,
   xbrlValidation,
   error,
-  calculationWarning
+  calculationWarning,
+  formulaValidation
 };
 const translations = {
   en: enTranslations,
@@ -2102,6 +2124,9 @@ class I18n {
   }
 }
 I18n.currentLanguage = "en";
+function isTotalLabel$1(preferredLabel) {
+  return !!(preferredLabel == null ? void 0 : preferredLabel.toLowerCase().includes("totallabel"));
+}
 class DraftStorageService {
   constructor(useSessionStorage = false) {
     this.DRAFT_DATA_KEY = "jupiter-form-draft-data";
@@ -2261,7 +2286,7 @@ class DraftStorageService {
   /**
    * Create metadata snapshot from current form state
    */
-  createMetadataSnapshot(periodStartDate, periodEndDate, language, selectedRoleIds, allSections, typedMemberData, periodPreferences, periodData, unitData, reportingLanguage = "en", repeatCounts, decimalsData, roleCompletedStates, hiddenColumns) {
+  createMetadataSnapshot(periodStartDate, periodEndDate, language, selectedRoleIds, allSections, typedMemberData, periodPreferences, periodData, unitData, reportingLanguage = "en", repeatCounts, decimalsData, roleCompletedStates, hiddenColumns, totalManuallyEditedData) {
     return {
       periodStartDate,
       periodEndDate,
@@ -2278,6 +2303,7 @@ class DraftStorageService {
       repeatCounts,
       roleCompletedStates,
       hiddenColumns,
+      totalManuallyEditedData,
       schemaVersion: this.STORAGE_VERSION
     };
   }
@@ -2300,6 +2326,882 @@ class DraftStorageService {
     return { compatible, warnings };
   }
 }
+const CALCULATION_TOLERANCE = 0.01;
+class FormulaExpressionError extends Error {
+  constructor(message, test, reason = "unsupported-syntax") {
+    super(message);
+    this.test = test;
+    this.reason = reason;
+    this.name = "FormulaExpressionError";
+  }
+}
+const TOKEN_PATTERN = /\s*(?:(\$[A-Za-z_][\w-]*)|(-?\d+(?:\.\d+)?)|([A-Za-z][\w:-]*)|('[^']*')|(\()|(\))|(\+)|(-)|(=))/y;
+function tokenize(test) {
+  const tokens = [];
+  TOKEN_PATTERN.lastIndex = 0;
+  let index = 0;
+  while (index < test.length) {
+    TOKEN_PATTERN.lastIndex = index;
+    const match = TOKEN_PATTERN.exec(test);
+    if (!match || match.index !== index) {
+      if (/^\s*$/.test(test.slice(index)))
+        break;
+      throw new FormulaExpressionError(`Unrecognized token at position ${index}: "${test.slice(index, index + 10)}..."`, test, "unsupported-syntax");
+    }
+    const [full, variable, number, ident, string, lparen, rparen, plus, minus, equals] = match;
+    if (variable)
+      tokens.push({ type: "VARIABLE", value: variable.slice(1) });
+    else if (number)
+      tokens.push({ type: "NUMBER", value: number });
+    else if (ident)
+      tokens.push({ type: "IDENT", value: ident });
+    else if (string)
+      tokens.push({ type: "STRING", value: string.slice(1, -1) });
+    else if (lparen)
+      tokens.push({ type: "LPAREN", value: lparen });
+    else if (rparen)
+      tokens.push({ type: "RPAREN", value: rparen });
+    else if (plus)
+      tokens.push({ type: "PLUS", value: plus });
+    else if (minus)
+      tokens.push({ type: "MINUS", value: minus });
+    else if (equals)
+      tokens.push({ type: "EQUALS", value: equals });
+    index += full.length;
+  }
+  tokens.push({ type: "EOF", value: "" });
+  return tokens;
+}
+class Parser {
+  constructor(tokens, test) {
+    this.tokens = tokens;
+    this.test = test;
+    this.pos = 0;
+  }
+  peek() {
+    return this.tokens[this.pos];
+  }
+  next() {
+    return this.tokens[this.pos++];
+  }
+  expect(type) {
+    const token = this.next();
+    if (token.type !== type) {
+      throw new FormulaExpressionError(
+        `Expected ${type} but got ${token.type} ("${token.value}")`,
+        this.test,
+        "parse-error"
+      );
+    }
+    return token;
+  }
+  parseBoolExpr() {
+    const node = this.parseOrExpr();
+    if (this.peek().type !== "EOF") {
+      throw new FormulaExpressionError(
+        `Unexpected trailing token "${this.peek().value}"`,
+        this.test,
+        "unsupported-syntax"
+      );
+    }
+    return node;
+  }
+  parseOrExpr() {
+    const terms = [this.parseAndExpr()];
+    while (this.peek().type === "IDENT" && this.peek().value === "or") {
+      this.next();
+      terms.push(this.parseAndExpr());
+    }
+    return terms.length === 1 ? terms[0] : { kind: "or", terms };
+  }
+  parseAndExpr() {
+    const terms = [this.parseBoolTerm()];
+    while (this.peek().type === "IDENT" && this.peek().value === "and") {
+      this.next();
+      terms.push(this.parseBoolTerm());
+    }
+    return terms.length === 1 ? terms[0] : { kind: "and", terms };
+  }
+  parseBoolTerm() {
+    const token = this.peek();
+    if (token.type === "IDENT" && token.value === "not") {
+      this.next();
+      this.expect("LPAREN");
+      const arg = this.parseOrExpr();
+      this.expect("RPAREN");
+      return { kind: "not", arg };
+    }
+    if (token.type === "IDENT" && token.value === "empty") {
+      this.next();
+      this.expect("LPAREN");
+      const variable = this.expect("VARIABLE").value;
+      this.expect("RPAREN");
+      return { kind: "empty", variable };
+    }
+    if (token.type === "IDENT" && token.value === "xff:has-fallback-value") {
+      this.next();
+      this.expect("LPAREN");
+      const inner = this.next();
+      if (inner.type !== "IDENT" || inner.value !== "xs:QName") {
+        throw new FormulaExpressionError(
+          `Expected xs:QName(...) inside xff:has-fallback-value(...), got "${inner.value}"`,
+          this.test,
+          "unsupported-syntax"
+        );
+      }
+      this.expect("LPAREN");
+      const variableName = this.expect("STRING").value;
+      this.expect("RPAREN");
+      this.expect("RPAREN");
+      return { kind: "hasFallbackValue", variableName };
+    }
+    const left = this.parseValueExpr();
+    const opToken = this.peek();
+    if (opToken.type === "EQUALS") {
+      this.next();
+      return { kind: "comparison", op: "=", left, right: this.parseValueExpr() };
+    }
+    if (opToken.type === "IDENT" && opToken.value === "eq") {
+      this.next();
+      return { kind: "comparison", op: "eq", left, right: this.parseValueExpr() };
+    }
+    throw new FormulaExpressionError(
+      `Expected a comparison operator ("=" or "eq") after value expression, got "${opToken.value}"`,
+      this.test,
+      "unsupported-syntax"
+    );
+  }
+  parseValueExpr() {
+    const terms = [];
+    let sign = 1;
+    if (this.peek().type === "PLUS") {
+      this.next();
+    } else if (this.peek().type === "MINUS") {
+      this.next();
+      sign = -1;
+    }
+    terms.push({ sign, term: this.parseValueTerm() });
+    while (this.peek().type === "PLUS" || this.peek().type === "MINUS") {
+      const opSign = this.next().type === "PLUS" ? 1 : -1;
+      terms.push({ sign: opSign, term: this.parseValueTerm() });
+    }
+    return terms.length === 1 && terms[0].sign === 1 ? terms[0].term : { kind: "additive", terms };
+  }
+  parseValueTerm() {
+    const token = this.peek();
+    if (token.type === "NUMBER") {
+      this.next();
+      return { kind: "number", value: Number(token.value) };
+    }
+    if (token.type === "VARIABLE") {
+      this.next();
+      return { kind: "variable", name: token.value };
+    }
+    if (token.type === "IDENT" && token.value === "sum") {
+      this.next();
+      this.expect("LPAREN");
+      const variable = this.expect("VARIABLE").value;
+      this.expect("RPAREN");
+      return { kind: "sum", variable };
+    }
+    if (token.type === "LPAREN") {
+      this.next();
+      const inner = this.parseValueExpr();
+      this.expect("RPAREN");
+      return inner;
+    }
+    throw new FormulaExpressionError(
+      `Expected a number, variable, sum(...), or parenthesized expression, got "${token.value}"`,
+      this.test,
+      "unsupported-syntax"
+    );
+  }
+}
+function lookup(bindings, name) {
+  return bindings.get(name);
+}
+function evalSum(variable, bindings) {
+  const binding = lookup(bindings, variable);
+  if (binding === void 0)
+    return 0;
+  if (Array.isArray(binding))
+    return binding.reduce((total, value) => total + value, 0);
+  return binding;
+}
+function evalValue(node, bindings, test) {
+  switch (node.kind) {
+    case "number":
+      return node.value;
+    case "sum":
+      return evalSum(node.variable, bindings);
+    case "variable": {
+      const binding = lookup(bindings, node.name);
+      if (binding === void 0) {
+        throw new FormulaExpressionError(
+          `Variable "$${node.name}" has no bound fact and cannot be evaluated directly (only sum()/empty() tolerate an unbound variable)`,
+          test,
+          "unbound-variable"
+        );
+      }
+      if (Array.isArray(binding)) {
+        throw new FormulaExpressionError(
+          `Variable "$${node.name}" is a sequence and must be wrapped in sum(...) to be used in arithmetic`,
+          test,
+          "unsupported-syntax"
+        );
+      }
+      return binding;
+    }
+    case "additive":
+      return node.terms.reduce((total, { sign, term }) => total + sign * evalValue(term, bindings, test), 0);
+  }
+}
+function evalBool(node, bindings, test, fallbackUsage) {
+  switch (node.kind) {
+    case "or":
+      return node.terms.some((term) => evalBool(term, bindings, test, fallbackUsage));
+    case "and":
+      return node.terms.every((term) => evalBool(term, bindings, test, fallbackUsage));
+    case "not":
+      return !evalBool(node.arg, bindings, test, fallbackUsage);
+    case "empty": {
+      const binding = lookup(bindings, node.variable);
+      return binding === void 0 || Array.isArray(binding) && binding.length === 0;
+    }
+    case "hasFallbackValue": {
+      const usedFallback = fallbackUsage.get(node.variableName);
+      if (usedFallback === void 0) {
+        throw new FormulaExpressionError(
+          `xff:has-fallback-value(xs:QName('${node.variableName}')) could not be evaluated — no fallback-usage tracked for this variable (either not one of this assertion's FACT_VARIABLEs, or it matched zero facts with no fallbackValue declared)`,
+          test,
+          "unbound-variable"
+        );
+      }
+      return usedFallback;
+    }
+    case "comparison": {
+      const left = evalValue(node.left, bindings, test);
+      const right = evalValue(node.right, bindings, test);
+      return Math.abs(left - right) < CALCULATION_TOLERANCE;
+    }
+  }
+}
+function evaluateFormulaTest(test, bindings, fallbackUsage = /* @__PURE__ */ new Map()) {
+  const tokens = tokenize(test);
+  const ast = new Parser(tokens, test).parseBoolExpr();
+  return evalBool(ast, bindings, test, fallbackUsage);
+}
+const EXISTENCE_TEST_PATTERN = /^\.\s*(eq|ne|gt|lt|ge|le)\s+(-?\d+(?:\.\d+)?)$/;
+function compareExistence(op, count, threshold) {
+  switch (op) {
+    case "eq":
+      return count === threshold;
+    case "ne":
+      return count !== threshold;
+    case "gt":
+      return count > threshold;
+    case "lt":
+      return count < threshold;
+    case "ge":
+      return count >= threshold;
+    case "le":
+      return count <= threshold;
+  }
+}
+function evaluateExistenceTest(test, matchedFactCount) {
+  const trimmed = (test ?? "").trim();
+  if (trimmed === "") {
+    return matchedFactCount > 0;
+  }
+  const clauses = trimmed.split(/\bor\b/);
+  return clauses.some((clause) => {
+    const match = EXISTENCE_TEST_PATTERN.exec(clause.trim());
+    if (!match) {
+      throw new FormulaExpressionError(`Unsupported existence-assertion test shape: "${clause.trim()}"`, trimmed, "unsupported-syntax");
+    }
+    const [, op, thresholdText] = match;
+    return compareExistence(op, matchedFactCount, Number(thresholdText));
+  });
+}
+function isTotalLabel(preferredLabel) {
+  return !!(preferredLabel == null ? void 0 : preferredLabel.toLowerCase().includes("totallabel"));
+}
+function isNegatedTotalLabel(preferredLabel) {
+  return !!(preferredLabel == null ? void 0 : preferredLabel.toLowerCase().includes("negatedtotallabel"));
+}
+function resolveValueNode(node, accessors, depth = 0) {
+  if (!accessors.isAbstract(node))
+    return node;
+  if (depth > 5)
+    return null;
+  const children = accessors.getChildren(node);
+  const nestedTotal = children.find((child) => isTotalLabel(accessors.getPreferredLabel(child)));
+  if (!nestedTotal)
+    return null;
+  return resolveValueNode(nestedTotal, accessors, depth + 1);
+}
+function resolveTotalGroupMembers(nodes, i2, lastTotalIdx, rawSiblings, accessors) {
+  if (lastTotalIdx < 0)
+    return rawSiblings;
+  const node = nodes[i2];
+  if (isNegatedTotalLabel(accessors.getPreferredLabel(node))) {
+    return rawSiblings.length > 0 ? rawSiblings : [nodes[lastTotalIdx]];
+  }
+  if (rawSiblings.length > 0) {
+    return [nodes[lastTotalIdx], ...rawSiblings];
+  }
+  if (isNegatedTotalLabel(accessors.getPreferredLabel(nodes[lastTotalIdx]))) {
+    let grandTotalIdx = -1;
+    for (let k = lastTotalIdx - 1; k >= 0; k--) {
+      if (isTotalLabel(accessors.getPreferredLabel(nodes[k]))) {
+        grandTotalIdx = k;
+        break;
+      }
+    }
+    return grandTotalIdx >= 0 ? [nodes[grandTotalIdx], nodes[lastTotalIdx]] : [nodes[lastTotalIdx]];
+  }
+  return [nodes[lastTotalIdx]];
+}
+function buildTotalGroupChildrenIndex(roots, accessors) {
+  const index = /* @__PURE__ */ new Map();
+  function registerGroup(totalNode, members) {
+    const resolvedIds = [];
+    for (const member of members) {
+      const resolved = resolveValueNode(member, accessors);
+      if (resolved)
+        resolvedIds.push(accessors.getId(resolved));
+    }
+    if (resolvedIds.length === 0)
+      return;
+    index.set(accessors.getId(totalNode), resolvedIds);
+  }
+  function traverse(nodes) {
+    for (let i2 = 0; i2 < nodes.length; i2++) {
+      const node = nodes[i2];
+      if (isTotalLabel(accessors.getPreferredLabel(node))) {
+        const children2 = accessors.getChildren(node);
+        if (children2.length === 0) {
+          let lastTotalIdx = -1;
+          for (let j = i2 - 1; j >= 0; j--) {
+            if (isTotalLabel(accessors.getPreferredLabel(nodes[j]))) {
+              lastTotalIdx = j;
+              break;
+            }
+          }
+          const rawSiblings = nodes.slice(lastTotalIdx + 1, i2);
+          const members = resolveTotalGroupMembers(nodes, i2, lastTotalIdx, rawSiblings, accessors);
+          if (members.length > 0)
+            registerGroup(node, members);
+        }
+      }
+      const children = accessors.getChildren(node);
+      if (children.length > 0)
+        traverse(children);
+    }
+  }
+  traverse(roots);
+  return index;
+}
+function isNonEmptyRawValue(rawValue) {
+  return rawValue !== void 0 && rawValue !== null && rawValue !== "";
+}
+function collectAllCandidates(formData) {
+  const candidates = [];
+  for (const conceptId of Object.keys(formData)) {
+    const columnValues = formData[conceptId] || {};
+    for (const columnId of Object.keys(columnValues)) {
+      if (isNonEmptyRawValue(columnValues[columnId])) {
+        candidates.push({ conceptId, columnId });
+      }
+    }
+  }
+  return candidates;
+}
+function indexConceptTree(concept, conceptByQName, conceptById, conceptIdByQName, conceptIdByQNameHasChildren, childrenIndex) {
+  const info = {
+    conceptId: concept.id,
+    qname: concept.name,
+    balance: concept.balance
+  };
+  conceptById.set(concept.id, info);
+  (conceptByQName.get(concept.name) ?? conceptByQName.set(concept.name, []).get(concept.name)).push(info);
+  const children = concept.children || [];
+  const hasOwnChildren = children.length > 0;
+  const alreadyHasChildren = conceptIdByQNameHasChildren.get(concept.name) === true;
+  if (!conceptIdByQName.has(concept.name) || hasOwnChildren && !alreadyHasChildren) {
+    conceptIdByQName.set(concept.name, concept.id);
+    conceptIdByQNameHasChildren.set(concept.name, hasOwnChildren);
+  }
+  childrenIndex.set(
+    concept.id,
+    children.map((child) => child.id)
+  );
+  children.forEach((child) => indexConceptTree(child, conceptByQName, conceptById, conceptIdByQName, conceptIdByQNameHasChildren, childrenIndex));
+}
+function indexMemberTree(member, memberQNameToId) {
+  if (!memberQNameToId.has(member.conceptName))
+    memberQNameToId.set(member.conceptName, member.id);
+  (member.children || []).forEach((child) => indexMemberTree(child, memberQNameToId));
+}
+const PRESENTATION_TOTAL_GROUP_ACCESSORS = {
+  getId: (concept) => concept.id,
+  getPreferredLabel: (concept) => concept.preferredLabel,
+  isAbstract: (concept) => concept.abstract === true,
+  getChildren: (concept) => concept.children || []
+};
+function buildFormulaResolutionContext(formData, columns, sections, hypercubeRoles, periodStartDate, periodEndDate) {
+  const conceptByQName = /* @__PURE__ */ new Map();
+  const conceptById = /* @__PURE__ */ new Map();
+  const conceptIdByQNamePerRole = /* @__PURE__ */ new Map();
+  const childrenByRole = /* @__PURE__ */ new Map();
+  const totalGroupChildrenByRole = /* @__PURE__ */ new Map();
+  sections.forEach((section2) => {
+    const childrenIndex = /* @__PURE__ */ new Map();
+    const conceptIdByQName = /* @__PURE__ */ new Map();
+    const conceptIdByQNameHasChildren = /* @__PURE__ */ new Map();
+    section2.concepts.forEach((concept) => indexConceptTree(concept, conceptByQName, conceptById, conceptIdByQName, conceptIdByQNameHasChildren, childrenIndex));
+    childrenByRole.set(section2.roleURI, childrenIndex);
+    conceptIdByQNamePerRole.set(section2.roleURI, conceptIdByQName);
+    totalGroupChildrenByRole.set(section2.roleURI, buildTotalGroupChildrenIndex(section2.concepts, PRESENTATION_TOTAL_GROUP_ACCESSORS));
+  });
+  const dimensionQNameToId = /* @__PURE__ */ new Map();
+  const memberQNameToId = /* @__PURE__ */ new Map();
+  (hypercubeRoles || []).forEach((role) => {
+    role.items.forEach((item) => {
+      item.dimensions.forEach((dimension) => {
+        if (!dimensionQNameToId.has(dimension.conceptName)) {
+          dimensionQNameToId.set(dimension.conceptName, dimension.id);
+        }
+        (dimension.members || []).forEach((member) => indexMemberTree(member, memberQNameToId));
+      });
+    });
+  });
+  return {
+    formData,
+    columns,
+    periodStartDate,
+    periodEndDate,
+    conceptByQName,
+    conceptById,
+    conceptIdByQNamePerRole,
+    childrenByRole,
+    totalGroupChildrenByRole,
+    dimensionQNameToId,
+    memberQNameToId,
+    allCandidates: collectAllCandidates(formData)
+  };
+}
+function collectDescendantConceptIds(childrenIndex, rootConceptId) {
+  const result = [];
+  const stack = [...childrenIndex.get(rootConceptId) || []];
+  const seen = /* @__PURE__ */ new Set();
+  while (stack.length > 0) {
+    const conceptId = stack.pop();
+    if (seen.has(conceptId))
+      continue;
+    seen.add(conceptId);
+    result.push(conceptId);
+    stack.push(...childrenIndex.get(conceptId) || []);
+  }
+  return result;
+}
+function candidateKey(candidate) {
+  return `${candidate.conceptId}::${candidate.columnId}`;
+}
+function resolveMatchedCandidates(variable, ctx) {
+  return intersectCandidates(variable.filters.map((filter2) => resolveFilter(filter2, ctx.allCandidates, ctx)));
+}
+function getColumn(ctx, columnId) {
+  return ctx.columns.find((column2) => column2.id === columnId);
+}
+function columnMatchesExplicitDimension(column2, axisId, memberId) {
+  if (!(column2 == null ? void 0 : column2.dimensionData))
+    return false;
+  const primaryMatch = column2.dimensionData.axisId === axisId && (memberId === void 0 || column2.dimensionData.memberId === memberId);
+  if (primaryMatch)
+    return true;
+  return (column2.dimensionData.combinations || []).some(
+    (combo) => combo.axisId === axisId && (memberId === void 0 || combo.memberId === memberId)
+  );
+}
+function columnMatchesTypedDimension(column2, axisId) {
+  if (!(column2 == null ? void 0 : column2.dimensionData))
+    return false;
+  if (column2.dimensionData.typedMemberId !== void 0 && column2.dimensionData.axisId === axisId)
+    return true;
+  return (column2.dimensionData.typedMembers || []).some((typedMember) => typedMember.axisId === axisId);
+}
+function paramTokenName(rawDate) {
+  if (!rawDate)
+    return void 0;
+  return rawDate.startsWith("$") ? rawDate.slice(1) : rawDate;
+}
+function resolveParamDate(paramToken, ctx) {
+  const isStart = paramToken.includes("StartDate");
+  const isEnd = paramToken.includes("EndDate") || paramToken === "FinancialReportingPeriodCurrentEndDateParam";
+  if (paramToken.startsWith("FinancialReportingPeriodCurrent")) {
+    return isStart ? { start: ctx.periodStartDate } : isEnd ? { end: ctx.periodEndDate } : void 0;
+  }
+  if (paramToken.startsWith("FinancialReportingPeriodPrePrevious") || paramToken.startsWith("FinancialReportingPeriodPrevious")) {
+    const previousYearColumn = findPreviousYearColumn(ctx);
+    if (!previousYearColumn)
+      return void 0;
+    return isStart ? { start: previousYearColumn.periodStartDate } : isEnd ? { end: previousYearColumn.periodEndDate } : void 0;
+  }
+  return void 0;
+}
+function findPreviousYearColumn(ctx) {
+  return ctx.columns.find((column2) => column2.periodEndDate !== void 0 && column2.periodEndDate < ctx.periodEndDate);
+}
+function columnEffectivePeriod(column2, ctx) {
+  return {
+    start: (column2 == null ? void 0 : column2.periodStartDate) ?? ctx.periodStartDate,
+    end: (column2 == null ? void 0 : column2.periodEndDate) ?? ctx.periodEndDate
+  };
+}
+function columnMatchesPeriod(column2, dateAttribute, ctx) {
+  const paramToken = paramTokenName(dateAttribute);
+  if (!paramToken)
+    return false;
+  const resolved = resolveParamDate(paramToken, ctx);
+  if (!resolved)
+    return false;
+  const period = columnEffectivePeriod(column2, ctx);
+  const targetDate = resolved.end ?? resolved.start;
+  return period.end === targetDate;
+}
+function unionCandidates(lists) {
+  const merged = /* @__PURE__ */ new Map();
+  lists.forEach((list) => list.forEach((candidate) => merged.set(candidateKey(candidate), candidate)));
+  return Array.from(merged.values());
+}
+function matchFilter(filter2, universe, ctx) {
+  var _a, _b;
+  switch (filter2.type) {
+    case "CONCEPT_NAME": {
+      const qname = filter2.attributes["concept.qname"];
+      const infos = qname ? ctx.conceptByQName.get(qname) : void 0;
+      if (!infos || infos.length === 0)
+        return [];
+      const conceptIds = new Set(infos.map((info) => info.conceptId));
+      return universe.filter((candidate) => conceptIds.has(candidate.conceptId));
+    }
+    case "CONCEPT_BALANCE": {
+      const balance = filter2.attributes["balance"];
+      return universe.filter((candidate) => {
+        var _a2;
+        return ((_a2 = ctx.conceptById.get(candidate.conceptId)) == null ? void 0 : _a2.balance) === balance;
+      });
+    }
+    case "CONCEPT_RELATION": {
+      const anchorQName = filter2.attributes["qname"];
+      const linkrole = filter2.attributes["linkrole"];
+      const axis = filter2.attributes["axis"];
+      const anchorConceptId = anchorQName && linkrole ? (_a = ctx.conceptIdByQNamePerRole.get(linkrole)) == null ? void 0 : _a.get(anchorQName) : void 0;
+      const childrenIndex = linkrole ? ctx.childrenByRole.get(linkrole) : void 0;
+      if (!anchorConceptId || !childrenIndex)
+        return [];
+      let relatedConceptIds;
+      if (axis === "descendant") {
+        relatedConceptIds = collectDescendantConceptIds(childrenIndex, anchorConceptId);
+      } else {
+        const nestedChildren = childrenIndex.get(anchorConceptId) || [];
+        relatedConceptIds = nestedChildren.length > 0 ? nestedChildren : ((_b = ctx.totalGroupChildrenByRole.get(linkrole ?? "")) == null ? void 0 : _b.get(anchorConceptId)) || [];
+      }
+      const relatedSet = new Set(relatedConceptIds);
+      return universe.filter((candidate) => relatedSet.has(candidate.conceptId));
+    }
+    case "EXPLICIT_DIMENSION": {
+      const dimensionQName = filter2.attributes["dimension.qname"];
+      const memberQName = filter2.attributes["member.qname"];
+      const axisId = dimensionQName ? ctx.dimensionQNameToId.get(dimensionQName) : void 0;
+      const memberId = memberQName ? ctx.memberQNameToId.get(memberQName) : void 0;
+      if (!axisId)
+        return [];
+      return universe.filter((candidate) => columnMatchesExplicitDimension(getColumn(ctx, candidate.columnId), axisId, memberId));
+    }
+    case "TYPED_DIMENSION": {
+      const dimensionQName = filter2.attributes["dimension.qname"];
+      const axisId = dimensionQName ? ctx.dimensionQNameToId.get(dimensionQName) : void 0;
+      if (!axisId)
+        return [];
+      return universe.filter((candidate) => columnMatchesTypedDimension(getColumn(ctx, candidate.columnId), axisId));
+    }
+    case "PERIOD_INSTANT":
+    case "PERIOD_END": {
+      const dateAttribute = filter2.attributes["date"];
+      return universe.filter((candidate) => columnMatchesPeriod(getColumn(ctx, candidate.columnId), dateAttribute, ctx));
+    }
+    case "OR_FILTER":
+      return unionCandidates(filter2.children.map((child) => resolveFilter(child, universe, ctx)));
+    case "ASPECT_COVER":
+      return universe;
+    default:
+      return [];
+  }
+}
+function resolveFilter(filter2, universe, ctx) {
+  const matched = matchFilter(filter2, universe, ctx);
+  if (!filter2.complement)
+    return matched;
+  const matchedKeys = new Set(matched.map(candidateKey));
+  return universe.filter((candidate) => !matchedKeys.has(candidateKey(candidate)));
+}
+function intersectCandidates(sets) {
+  if (sets.length === 0)
+    return [];
+  return sets.reduce((acc, set) => {
+    const setKeys = new Set(set.map(candidateKey));
+    return acc.filter((candidate) => setKeys.has(candidateKey(candidate)));
+  });
+}
+function resolveFormulaVariable(variable, ctx) {
+  const matched = resolveMatchedCandidates(variable, ctx);
+  const values = matched.map((candidate) => {
+    var _a;
+    return parseFloat((_a = ctx.formData[candidate.conceptId]) == null ? void 0 : _a[candidate.columnId]);
+  }).filter((value) => !Number.isNaN(value));
+  if (variable.bindAsSequence) {
+    if (values.length === 0 && variable.fallbackValue === "()")
+      return [];
+    if (values.length === 0)
+      return void 0;
+    return values;
+  }
+  if (values.length === 0)
+    return void 0;
+  if (values.length > 1) {
+    console.warn(
+      `[formula-variable-resolver] Variable "${variable.name}" is scalar (bindAsSequence: false) but matched ${values.length} facts; using the first match by column order. This can legitimately happen when filters under-constrain the candidate set.`
+    );
+  }
+  return values[0];
+}
+function resolveFormulaVariableMatchCount(variable, ctx) {
+  return resolveMatchedCandidates(variable, ctx).length;
+}
+function resolveFormulaVariableUsedFallback(variable, ctx) {
+  const matchCount = resolveFormulaVariableMatchCount(variable, ctx);
+  if (matchCount > 0)
+    return false;
+  if (variable.fallbackValue !== void 0)
+    return true;
+  return void 0;
+}
+function collectConceptNameQNames(filters) {
+  const qnames = [];
+  for (const filter2 of filters) {
+    if (filter2.type === "CONCEPT_NAME") {
+      const qname = filter2.attributes["concept.qname"];
+      if (qname)
+        qnames.push(qname);
+    } else if (filter2.type === "OR_FILTER") {
+      qnames.push(...collectConceptNameQNames(filter2.children));
+    }
+  }
+  return qnames;
+}
+function resolveVariableConceptQNames(variable) {
+  return collectConceptNameQNames(variable.filters);
+}
+function resolveVariableColumnsForConcept(variable, targetConceptId, ctx) {
+  const universe = ctx.columns.map((column2) => ({ conceptId: targetConceptId, columnId: column2.id }));
+  const resolved = intersectCandidates(variable.filters.map((filter2) => resolveFilter(filter2, universe, ctx)));
+  return resolved.map((candidate) => candidate.columnId);
+}
+function buildAssertionBindings(assertion, ctx) {
+  const bindings = /* @__PURE__ */ new Map();
+  for (const variable of assertion.variables) {
+    bindings.set(variable.name, resolveFormulaVariable(variable, ctx));
+  }
+  return bindings;
+}
+function buildAssertionFallbackUsage(assertion, ctx) {
+  var _a;
+  const usesHasFallbackValue = ((_a = assertion.test) == null ? void 0 : _a.includes("has-fallback-value")) || assertion.preconditions.some((precondition) => precondition.test.includes("has-fallback-value"));
+  if (!usesHasFallbackValue)
+    return /* @__PURE__ */ new Map();
+  const fallbackUsage = /* @__PURE__ */ new Map();
+  for (const variable of assertion.variables) {
+    const usedFallback = resolveFormulaVariableUsedFallback(variable, ctx);
+    if (usedFallback !== void 0)
+      fallbackUsage.set(variable.name, usedFallback);
+  }
+  return fallbackUsage;
+}
+function evaluateAssertionPreconditions(preconditions, bindings, fallbackUsage = /* @__PURE__ */ new Map()) {
+  if (preconditions.length === 0)
+    return { satisfied: true };
+  for (const precondition of preconditions) {
+    let result;
+    try {
+      result = evaluateFormulaTest(precondition.test, bindings, fallbackUsage);
+    } catch (error2) {
+      if (error2 instanceof FormulaExpressionError) {
+        return { satisfied: false, skipReason: "unresolvable" };
+      }
+      throw error2;
+    }
+    if (!result) {
+      return { satisfied: false, skipReason: "precondition" };
+    }
+  }
+  return { satisfied: true };
+}
+class FormulaValidationService {
+  /**
+   * Evaluates every assertion in `xbrlInput.formula[0].roles` (only the first entrypoint,
+   * consistent with how xbrl-form-builder.ts uses presentation/hypercube data) against the
+   * given resolution context. One bad assertion never aborts the other 783 — resolution/
+   * evaluation errors are caught per-assertion and recorded as skipped, not thrown.
+   */
+  evaluate(xbrlInput, ctx, language) {
+    var _a;
+    const formulaData = (_a = xbrlInput.formula) == null ? void 0 : _a[0];
+    if (!formulaData)
+      return [];
+    const results = [];
+    for (const role of formulaData.roles) {
+      for (const assertion of role.assertions) {
+        results.push(this._evaluateAssertion(assertion, role, ctx, language));
+      }
+    }
+    return results;
+  }
+  summarize(results) {
+    const summary = {
+      totalAssertions: results.length,
+      evaluated: 0,
+      skipped: 0,
+      passed: 0,
+      failed: 0,
+      failedWarnings: 0,
+      failedErrors: 0
+    };
+    for (const result of results) {
+      if (result.skipped) {
+        summary.skipped += 1;
+        continue;
+      }
+      summary.evaluated += 1;
+      if (result.satisfied) {
+        summary.passed += 1;
+      } else {
+        summary.failed += 1;
+        if (result.severity === "ERROR")
+          summary.failedErrors += 1;
+        else
+          summary.failedWarnings += 1;
+      }
+    }
+    return summary;
+  }
+  _evaluateAssertion(assertion, role, ctx, language) {
+    try {
+      const bindings = buildAssertionBindings(assertion, ctx);
+      const fallbackUsage = buildAssertionFallbackUsage(assertion, ctx);
+      const precondition = evaluateAssertionPreconditions(assertion.preconditions, bindings, fallbackUsage);
+      if (!precondition.satisfied) {
+        return this._skippedResult(assertion, role, precondition.skipReason ?? "unresolvable");
+      }
+      if (assertion.type === "EXISTENCE_ASSERTION") {
+        const matchedFactCount = resolveFormulaVariableMatchCount(assertion.variables[0], ctx);
+        const satisfied2 = evaluateExistenceTest(assertion.test, matchedFactCount);
+        return this._evaluatedResult(assertion, role, ctx, satisfied2, language, matchedFactCount);
+      }
+      const satisfied = evaluateFormulaTest(assertion.test, bindings, fallbackUsage);
+      return this._evaluatedResult(assertion, role, ctx, satisfied, language);
+    } catch (error2) {
+      if (error2 instanceof FormulaExpressionError) {
+        console.warn(`[FormulaValidationService] Assertion "${assertion.id}" could not be evaluated (${error2.reason}): ${error2.message}`);
+        return this._skippedResult(assertion, role, "unresolvable");
+      }
+      throw error2;
+    }
+  }
+  _skippedResult(assertion, role, skipReason) {
+    return {
+      assertionId: assertion.id,
+      roleURI: role.roleURI,
+      roleLabel: role.role,
+      type: assertion.type,
+      severity: assertion.severity,
+      satisfied: false,
+      skipped: true,
+      skipReason
+    };
+  }
+  _evaluatedResult(assertion, role, ctx, satisfied, language, matchedFactCount) {
+    const message = satisfied ? void 0 : this._pickMessage(assertion, language);
+    return {
+      assertionId: assertion.id,
+      roleURI: role.roleURI,
+      roleLabel: role.role,
+      type: assertion.type,
+      severity: assertion.severity,
+      satisfied,
+      skipped: false,
+      message,
+      matchedFactCount,
+      conceptLinks: message ? this._buildConceptLinks(assertion, role.roleURI, ctx, message) : void 0
+    };
+  }
+  _pickMessage(assertion, language) {
+    const messages = assertion.messages;
+    if (messages.length === 0)
+      return void 0;
+    const message = messages.find((m) => m.xmlLang === language) ?? messages.find((m) => m.xmlLang === "en") ?? messages[0];
+    return this._stripTechnicalDetail(message.text);
+  }
+  /**
+   * Taxonomy-authored messages append raw XBRL Formula/XPath debug expressions after the
+   * human-readable sentence, delimited by " | {...}" (e.g. `xff:has-fallback-value(...)`,
+   * `varArc_...` variable names) — see the fixture's `*_formula.json` message text. That debug
+   * payload is meaningless to a non-technical filer, so only the sentence preceding it is shown.
+   */
+  _stripTechnicalDetail(text) {
+    const braceIndex = text.indexOf("{");
+    if (braceIndex === -1)
+      return text.trim();
+    return text.slice(0, braceIndex).replace(/\|\s*$/, "").trim();
+  }
+  /**
+   * JDF-059: resolves every concept the assertion's variables name directly (JDF-045's
+   * `resolveVariableConceptQNames`) to a clickable fact location — but only the ones the
+   * (already-stripped) message text actually mentions by backtick-quoted local name, e.g.
+   * `` `Equity` `` — a concept a variable references internally (say, as a dimensional
+   * exclusion) but the message never calls out by name has nothing for the user to click on, so
+   * it's left out rather than guessed at. Column resolution reuses the assertion's own filters
+   * (`resolveVariableColumnsForConcept`), so the link always points at the exact fact this
+   * specific assertion run cared about — never just "some field for this concept" — including an
+   * empty one for a failed "MUST exist" assertion, so the user can navigate straight to where the
+   * missing value belongs.
+   */
+  _buildConceptLinks(assertion, roleURI, ctx, message) {
+    var _a, _b, _c;
+    const links = [];
+    const seenLabels = /* @__PURE__ */ new Set();
+    for (const variable of assertion.variables) {
+      for (const qname of resolveVariableConceptQNames(variable)) {
+        const conceptId = ((_a = ctx.conceptIdByQNamePerRole.get(roleURI)) == null ? void 0 : _a.get(qname)) ?? ((_c = (_b = ctx.conceptByQName.get(qname)) == null ? void 0 : _b[0]) == null ? void 0 : _c.conceptId);
+        if (!conceptId)
+          continue;
+        const label = qname.includes(":") ? qname.split(":").pop() : qname;
+        if (seenLabels.has(label))
+          continue;
+        if (!new RegExp("`" + this._escapeRegExp(label) + "`").test(message))
+          continue;
+        const columns = resolveVariableColumnsForConcept(variable, conceptId, ctx);
+        links.push({ label, conceptQName: qname, conceptId, columnId: columns[0] });
+        seenLabels.add(label);
+      }
+    }
+    return links;
+  }
+  _escapeRegExp(text) {
+    return text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  }
+}
 class FactMatcher {
   /**
    * Find a matching fact for a given cell context
@@ -3153,15 +4055,15 @@ function determineInputTypeFromBaseChain(baseTypeChain, datatypes) {
     placeholder: I18n.t("field.enterValue")
   };
 }
-var __defProp$6 = Object.defineProperty;
-var __getOwnPropDesc$6 = Object.getOwnPropertyDescriptor;
-var __decorateClass$6 = (decorators, target, key, kind) => {
-  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$6(target, key) : target;
+var __defProp$7 = Object.defineProperty;
+var __getOwnPropDesc$7 = Object.getOwnPropertyDescriptor;
+var __decorateClass$7 = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$7(target, key) : target;
   for (var i2 = decorators.length - 1, decorator; i2 >= 0; i2--)
     if (decorator = decorators[i2])
       result = (kind ? decorator(target, key, result) : decorator(result)) || result;
   if (kind && result)
-    __defProp$6(target, key, result);
+    __defProp$7(target, key, result);
   return result;
 };
 let JupiterFormField = class extends LitElement {
@@ -4178,6 +5080,7 @@ let JupiterFormField = class extends LitElement {
             <button
               class="period-icon-btn"
               type="button"
+              tabindex="-1"
               @click="${this._handlePeriodIconClick}"
               title="Edit period"
             >
@@ -4674,99 +5577,99 @@ JupiterFormField.styles = css`
       animation: concept-highlight-pulse 10s ease-out forwards;
     }
   `;
-__decorateClass$6([
+__decorateClass$7([
   n2({ type: Object })
 ], JupiterFormField.prototype, "field", 2);
-__decorateClass$6([
+__decorateClass$7([
   n2({ type: String })
 ], JupiterFormField.prototype, "conceptId", 2);
-__decorateClass$6([
+__decorateClass$7([
   n2({ type: String })
 ], JupiterFormField.prototype, "conceptType", 2);
-__decorateClass$6([
+__decorateClass$7([
   n2({ type: Array })
 ], JupiterFormField.prototype, "datatypes", 2);
-__decorateClass$6([
+__decorateClass$7([
   n2({ type: Array })
 ], JupiterFormField.prototype, "defaultUnits", 2);
-__decorateClass$6([
+__decorateClass$7([
   n2({ type: String })
 ], JupiterFormField.prototype, "columnId", 2);
-__decorateClass$6([
+__decorateClass$7([
   n2()
 ], JupiterFormField.prototype, "value", 2);
-__decorateClass$6([
+__decorateClass$7([
   n2({ type: Boolean })
 ], JupiterFormField.prototype, "disabled", 2);
-__decorateClass$6([
+__decorateClass$7([
   n2({ type: String })
 ], JupiterFormField.prototype, "locale", 2);
-__decorateClass$6([
+__decorateClass$7([
   n2({ type: Boolean })
 ], JupiterFormField.prototype, "hideLabel", 2);
-__decorateClass$6([
+__decorateClass$7([
   n2({ type: String })
 ], JupiterFormField.prototype, "mode", 2);
-__decorateClass$6([
+__decorateClass$7([
   n2({ type: Object })
 ], JupiterFormField.prototype, "masterData", 2);
-__decorateClass$6([
+__decorateClass$7([
   n2({ type: Array })
 ], JupiterFormField.prototype, "facts", 2);
-__decorateClass$6([
+__decorateClass$7([
   n2({ type: Object })
 ], JupiterFormField.prototype, "column", 2);
-__decorateClass$6([
+__decorateClass$7([
   n2({ type: String })
 ], JupiterFormField.prototype, "periodStartDate", 2);
-__decorateClass$6([
+__decorateClass$7([
   n2({ type: String })
 ], JupiterFormField.prototype, "periodEndDate", 2);
-__decorateClass$6([
+__decorateClass$7([
   n2({ type: String })
 ], JupiterFormField.prototype, "periodInstantDate", 2);
-__decorateClass$6([
+__decorateClass$7([
   n2({ type: String })
 ], JupiterFormField.prototype, "unit", 2);
-__decorateClass$6([
+__decorateClass$7([
   n2({ type: String })
 ], JupiterFormField.prototype, "decimals", 2);
-__decorateClass$6([
+__decorateClass$7([
   n2({ type: String })
 ], JupiterFormField.prototype, "globalDecimals", 2);
-__decorateClass$6([
+__decorateClass$7([
   n2({ type: Object })
 ], JupiterFormField.prototype, "typedMemberValues", 2);
-__decorateClass$6([
+__decorateClass$7([
   r()
 ], JupiterFormField.prototype, "_errors", 2);
-__decorateClass$6([
+__decorateClass$7([
   r()
 ], JupiterFormField.prototype, "_xbrlErrors", 2);
-__decorateClass$6([
+__decorateClass$7([
   r()
 ], JupiterFormField.prototype, "_touched", 2);
-__decorateClass$6([
+__decorateClass$7([
   r()
 ], JupiterFormField.prototype, "_showPeriodPopup", 2);
-__decorateClass$6([
+__decorateClass$7([
   r()
 ], JupiterFormField.prototype, "_availableUnits", 2);
-__decorateClass$6([
+__decorateClass$7([
   r()
 ], JupiterFormField.prototype, "_numericDraftValue", 2);
-JupiterFormField = __decorateClass$6([
+JupiterFormField = __decorateClass$7([
   t$1("jupiter-form-field")
 ], JupiterFormField);
-var __defProp$5 = Object.defineProperty;
-var __getOwnPropDesc$5 = Object.getOwnPropertyDescriptor;
-var __decorateClass$5 = (decorators, target, key, kind) => {
-  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$5(target, key) : target;
+var __defProp$6 = Object.defineProperty;
+var __getOwnPropDesc$6 = Object.getOwnPropertyDescriptor;
+var __decorateClass$6 = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$6(target, key) : target;
   for (var i2 = decorators.length - 1, decorator; i2 >= 0; i2--)
     if (decorator = decorators[i2])
       result = (kind ? decorator(target, key, result) : decorator(result)) || result;
   if (kind && result)
-    __defProp$5(target, key, result);
+    __defProp$6(target, key, result);
   return result;
 };
 let JupiterConceptTree = class extends LitElement {
@@ -5036,6 +5939,7 @@ let JupiterConceptTree = class extends LitElement {
     const hasChildren = this.concept.children && this.concept.children.length > 0;
     const level = this.concept.level || 0;
     const isAbstract = this.concept.abstract || false;
+    const isTotal = isTotalLabel$1(this.concept.preferredLabel);
     return html`
       <!-- Concept Name Cell (Left Column) -->
       <td class="concept-name-cell ${isAbstract ? "abstract" : hasChildren ? "" : "leaf"} ${this.rowFocused ? "row-focused" : ""}">
@@ -5045,7 +5949,7 @@ let JupiterConceptTree = class extends LitElement {
                @click="${this._toggleExpanded}">
             ${hasChildren ? "▶" : ""}
           </div>
-          <div class="concept-label"
+          <div class="concept-label ${isTotal ? "total-concept-label" : ""}"
                @click="${this._toggleExpanded}"
                title="${this.concept.id}${this.concept.description ? " - " + this.concept.description : ""}">
             ${this.concept.label}
@@ -5053,14 +5957,14 @@ let JupiterConceptTree = class extends LitElement {
           ${this.concept.balance ? html`
             <div class="concept-balance ${this.concept.balance}">${this.concept.balance}</div>
           ` : ""}
-          <button class="concept-info-btn" type="button" title="${I18n.t("conceptInfo.title")}"
+          <button class="concept-info-btn" type="button" tabindex="-1" title="${I18n.t("conceptInfo.title")}"
             @click="${this._openInfoDialog}">ℹ</button>
           ${this.showAddButton ? html`
-            <button class="repeat-btn" type="button" title="Add row"
+            <button class="repeat-btn" type="button" tabindex="-1" title="Add row"
               @click="${this._handleAddRepeat}">+</button>
           ` : ""}
           ${this.showRemoveButton ? html`
-            <button class="repeat-btn remove" type="button" title="Remove row"
+            <button class="repeat-btn remove" type="button" tabindex="-1" title="Remove row"
               @click="${this._handleRemoveRepeat}">−</button>
           ` : ""}
         </div>
@@ -5078,11 +5982,12 @@ let JupiterConceptTree = class extends LitElement {
       const storedDecimals = (_d = (_c = this.decimalsData) == null ? void 0 : _c[this.concept.id]) == null ? void 0 : _d[column2.id];
       const calcMismatch = this.mode !== "readonly" ? (_e = this.calculationMismatches) == null ? void 0 : _e.get(`${this.concept.id}__${column2.id}`) : void 0;
       return html`
-          <td class="field-cell ${!shouldShowField ? "empty" : ""} ${isAbstract ? "abstract-row" : ""} ${this.highlightType && column2.id === this.highlightColumnId ? "highlight-" + this.highlightType : ""} ${calcMismatch ? "calc-warning" : ""} ${this.rowFocused ? "row-focused" : ""}">
+          <td class="field-cell ${!shouldShowField ? "empty" : ""} ${isAbstract ? "abstract-row" : ""} ${isTotal ? "total-row" : ""} ${this.highlightType && column2.id === this.highlightColumnId ? "highlight-" + this.highlightType : ""} ${calcMismatch ? "calc-warning" : ""} ${this.rowFocused ? "row-focused" : ""}">
             ${calcMismatch ? html`
               <button
                 class="calc-warning-badge"
                 type="button"
+                tabindex="-1"
                 title="${calcMismatch.message}"
                 @click="${(e2) => this._openCalculationWarningDialog(e2, calcMismatch)}"
               >!</button>
@@ -5199,6 +6104,10 @@ JupiterConceptTree.styles = css`
       min-width: 0; /* Allows flex item to shrink below content size */
     }
 
+    .concept-label.total-concept-label {
+      font-weight: 700;
+    }
+
     .concept-balance {
       margin-left: 8px;
       font-size: 11px;
@@ -5290,6 +6199,10 @@ JupiterConceptTree.styles = css`
       color: #fff;
     }
 
+    .field-cell.total-row {
+      background: var(--jupiter-total-cell-background, rgba(0, 0, 0, 0.045));
+    }
+
     .field-cell.highlight-total {
       background: rgba(25, 118, 210, 0.15);
     }
@@ -5395,90 +6308,90 @@ JupiterConceptTree.styles = css`
     }
 
   `;
-__decorateClass$5([
+__decorateClass$6([
   n2({ type: Object })
 ], JupiterConceptTree.prototype, "concept", 2);
-__decorateClass$5([
+__decorateClass$6([
   n2({ type: Array })
 ], JupiterConceptTree.prototype, "columns", 2);
-__decorateClass$5([
+__decorateClass$6([
   n2({ type: Object })
 ], JupiterConceptTree.prototype, "formData", 2);
-__decorateClass$5([
+__decorateClass$6([
   n2({ type: Object })
 ], JupiterConceptTree.prototype, "periodData", 2);
-__decorateClass$5([
+__decorateClass$6([
   n2({ type: Object })
 ], JupiterConceptTree.prototype, "unitData", 2);
-__decorateClass$5([
+__decorateClass$6([
   n2({ type: Object })
 ], JupiterConceptTree.prototype, "decimalsData", 2);
-__decorateClass$5([
+__decorateClass$6([
   n2({ type: String })
 ], JupiterConceptTree.prototype, "globalDecimals", 2);
-__decorateClass$5([
+__decorateClass$6([
   n2({ type: Array })
 ], JupiterConceptTree.prototype, "defaultUnits", 2);
-__decorateClass$5([
+__decorateClass$6([
   n2({ type: Boolean })
 ], JupiterConceptTree.prototype, "disabled", 2);
-__decorateClass$5([
+__decorateClass$6([
   n2({ type: String })
 ], JupiterConceptTree.prototype, "locale", 2);
-__decorateClass$5([
+__decorateClass$6([
   n2({ type: Set })
 ], JupiterConceptTree.prototype, "expandedConcepts", 2);
-__decorateClass$5([
+__decorateClass$6([
   n2({ type: Array })
 ], JupiterConceptTree.prototype, "datatypes", 2);
-__decorateClass$5([
+__decorateClass$6([
   n2({ type: String })
 ], JupiterConceptTree.prototype, "mode", 2);
-__decorateClass$5([
+__decorateClass$6([
   n2({ type: Object })
 ], JupiterConceptTree.prototype, "masterData", 2);
-__decorateClass$5([
+__decorateClass$6([
   n2({ type: Array })
 ], JupiterConceptTree.prototype, "facts", 2);
-__decorateClass$5([
+__decorateClass$6([
   n2({ type: Object })
 ], JupiterConceptTree.prototype, "typedMemberData", 2);
-__decorateClass$5([
+__decorateClass$6([
   n2({ type: Boolean })
 ], JupiterConceptTree.prototype, "showAddButton", 2);
-__decorateClass$5([
+__decorateClass$6([
   n2({ type: Boolean })
 ], JupiterConceptTree.prototype, "showRemoveButton", 2);
-__decorateClass$5([
+__decorateClass$6([
   n2({ type: String })
 ], JupiterConceptTree.prototype, "highlightType", 2);
-__decorateClass$5([
+__decorateClass$6([
   n2({ type: String })
 ], JupiterConceptTree.prototype, "highlightColumnId", 2);
-__decorateClass$5([
+__decorateClass$6([
   n2({ type: Object })
 ], JupiterConceptTree.prototype, "calculationMismatches", 2);
-__decorateClass$5([
+__decorateClass$6([
   n2({ type: String })
 ], JupiterConceptTree.prototype, "language", 2);
-__decorateClass$5([
+__decorateClass$6([
   n2({ type: Boolean })
 ], JupiterConceptTree.prototype, "rowFocused", 2);
-__decorateClass$5([
+__decorateClass$6([
   r()
 ], JupiterConceptTree.prototype, "_expanded", 2);
-JupiterConceptTree = __decorateClass$5([
+JupiterConceptTree = __decorateClass$6([
   t$1("jupiter-concept-tree")
 ], JupiterConceptTree);
-var __defProp$4 = Object.defineProperty;
-var __getOwnPropDesc$4 = Object.getOwnPropertyDescriptor;
-var __decorateClass$4 = (decorators, target, key, kind) => {
-  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$4(target, key) : target;
+var __defProp$5 = Object.defineProperty;
+var __getOwnPropDesc$5 = Object.getOwnPropertyDescriptor;
+var __decorateClass$5 = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$5(target, key) : target;
   for (var i2 = decorators.length - 1, decorator; i2 >= 0; i2--)
     if (decorator = decorators[i2])
       result = (kind ? decorator(target, key, result) : decorator(result)) || result;
   if (kind && result)
-    __defProp$4(target, key, result);
+    __defProp$5(target, key, result);
   return result;
 };
 let JupiterAddColumnDialog = class extends LitElement {
@@ -6087,48 +7000,48 @@ JupiterAddColumnDialog.styles = css`
       line-height: 1.4;
     }
   `;
-__decorateClass$4([
+__decorateClass$5([
   n2({ type: String })
 ], JupiterAddColumnDialog.prototype, "periodType", 2);
-__decorateClass$4([
+__decorateClass$5([
   n2({ type: Boolean })
 ], JupiterAddColumnDialog.prototype, "open", 2);
-__decorateClass$4([
+__decorateClass$5([
   n2({ type: Array })
 ], JupiterAddColumnDialog.prototype, "availableDimensions", 2);
-__decorateClass$4([
+__decorateClass$5([
   n2({ type: String })
 ], JupiterAddColumnDialog.prototype, "periodStartDate", 2);
-__decorateClass$4([
+__decorateClass$5([
   n2({ type: String })
 ], JupiterAddColumnDialog.prototype, "periodEndDate", 2);
-__decorateClass$4([
+__decorateClass$5([
   r()
 ], JupiterAddColumnDialog.prototype, "_startDate", 2);
-__decorateClass$4([
+__decorateClass$5([
   r()
 ], JupiterAddColumnDialog.prototype, "_endDate", 2);
-__decorateClass$4([
+__decorateClass$5([
   r()
 ], JupiterAddColumnDialog.prototype, "_instantDate", 2);
-__decorateClass$4([
+__decorateClass$5([
   r()
 ], JupiterAddColumnDialog.prototype, "_selectedType", 2);
-__decorateClass$4([
+__decorateClass$5([
   r()
 ], JupiterAddColumnDialog.prototype, "_selectedDimensions", 2);
-JupiterAddColumnDialog = __decorateClass$4([
+JupiterAddColumnDialog = __decorateClass$5([
   t$1("jupiter-add-column-dialog")
 ], JupiterAddColumnDialog);
-var __defProp$3 = Object.defineProperty;
-var __getOwnPropDesc$3 = Object.getOwnPropertyDescriptor;
-var __decorateClass$3 = (decorators, target, key, kind) => {
-  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$3(target, key) : target;
+var __defProp$4 = Object.defineProperty;
+var __getOwnPropDesc$4 = Object.getOwnPropertyDescriptor;
+var __decorateClass$4 = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$4(target, key) : target;
   for (var i2 = decorators.length - 1, decorator; i2 >= 0; i2--)
     if (decorator = decorators[i2])
       result = (kind ? decorator(target, key, result) : decorator(result)) || result;
   if (kind && result)
-    __defProp$3(target, key, result);
+    __defProp$4(target, key, result);
   return result;
 };
 let JupiterFormSection = class extends LitElement {
@@ -6155,6 +7068,7 @@ let JupiterFormSection = class extends LitElement {
     this.periodEndDate = "";
     this.language = "en";
     this.calculationEnabled = false;
+    this.totalManuallyEditedData = {};
     this._expanded = true;
     this._showAddColumnDialog = false;
     this._sectionPeriodType = "duration";
@@ -6179,6 +7093,7 @@ let JupiterFormSection = class extends LitElement {
     this._memberParentMap = /* @__PURE__ */ new Map();
     this._totalConceptMap = /* @__PURE__ */ new Map();
     this._totalChildConceptsMap = /* @__PURE__ */ new Map();
+    this._sessionManuallyEditedTotals = /* @__PURE__ */ new Set();
   }
   connectedCallback() {
     super.connectedCallback();
@@ -6206,6 +7121,9 @@ let JupiterFormSection = class extends LitElement {
         this._clearCalculationState();
       }
     }
+    if (changedProperties.has("totalManuallyEditedData")) {
+      this._sessionManuallyEditedTotals.clear();
+    }
   }
   _checkAndExpandFirstSection() {
     if (this.isFirstSection && this.section && this.section.concepts) {
@@ -6355,6 +7273,15 @@ let JupiterFormSection = class extends LitElement {
   }
   _handleFieldChange(event) {
     event.stopPropagation();
+    const { conceptId, columnId } = event.detail || {};
+    if (conceptId && columnId && this._totalConceptMap.has(conceptId)) {
+      this._sessionManuallyEditedTotals.add(`${conceptId}__${columnId}`);
+      this.dispatchEvent(new CustomEvent("total-manually-edited", {
+        detail: { conceptId, columnId },
+        bubbles: true,
+        composed: true
+      }));
+    }
     this.dispatchEvent(new CustomEvent("field-change", {
       detail: event.detail,
       bubbles: true,
@@ -6383,6 +7310,13 @@ let JupiterFormSection = class extends LitElement {
     }
     return result;
   }
+  _isTotalManuallyEdited(totalConceptId, columnId) {
+    var _a, _b;
+    const key = `${totalConceptId}__${columnId}`;
+    if (this._sessionManuallyEditedTotals.has(key))
+      return true;
+    return ((_b = (_a = this.totalManuallyEditedData) == null ? void 0 : _a[totalConceptId]) == null ? void 0 : _b[columnId]) === true;
+  }
   /**
    * Returns true when every column cell for a concept has no value.
    * Used in readonly mode to hide fully-blank rows.
@@ -6463,7 +7397,7 @@ let JupiterFormSection = class extends LitElement {
    * matching is the single source of truth for "is this row a total" everywhere in this file.
    */
   static _isTotalLabel(preferredLabel) {
-    return !!(preferredLabel == null ? void 0 : preferredLabel.toLowerCase().includes("totallabel"));
+    return isTotalLabel$1(preferredLabel);
   }
   /**
    * JDF-041: distinguishes a self-contained "deduction block" subtotal (negatedTotalLabel, e.g.
@@ -6584,10 +7518,29 @@ let JupiterFormSection = class extends LitElement {
     }
   }
   _evaluateTotal(totalConceptId, columnId) {
-    var _a;
+    var _a, _b;
     const totalConcept = this._totalConceptMap.get(totalConceptId);
-    const totalRaw = (_a = this.formData[totalConceptId]) == null ? void 0 : _a[columnId];
     const key = `${totalConceptId}__${columnId}`;
+    const children = this._totalChildConceptsMap.get(totalConceptId) || [];
+    const { calculatedSum, hasAnyValue, breakdown } = this._buildCalculationBreakdown(
+      children,
+      this.formData,
+      columnId,
+      totalConcept.balance
+    );
+    if (!this._isTotalManuallyEdited(totalConceptId, columnId)) {
+      if (hasAnyValue) {
+        const currentRaw = (_a = this.formData[totalConceptId]) == null ? void 0 : _a[columnId];
+        const currentValue = parseFloat(currentRaw);
+        const isBlank = currentRaw === null || currentRaw === void 0 || currentRaw === "";
+        if (isBlank || isNaN(currentValue) || !JupiterFormSection._checkTotal(currentValue, calculatedSum)) {
+          this._dispatchCalculationTotalAutoPopulated(totalConceptId, columnId, calculatedSum);
+        }
+      }
+      this._clearCalculationMismatch(key);
+      return;
+    }
+    const totalRaw = (_b = this.formData[totalConceptId]) == null ? void 0 : _b[columnId];
     if (totalRaw === null || totalRaw === void 0 || totalRaw === "") {
       this._clearCalculationMismatch(key);
       return;
@@ -6597,13 +7550,6 @@ let JupiterFormSection = class extends LitElement {
       this._clearCalculationMismatch(key);
       return;
     }
-    const children = this._totalChildConceptsMap.get(totalConceptId) || [];
-    const { calculatedSum, hasAnyValue, breakdown } = this._buildCalculationBreakdown(
-      children,
-      this.formData,
-      columnId,
-      totalConcept.balance
-    );
     if (!hasAnyValue || JupiterFormSection._checkTotal(totalValue, calculatedSum)) {
       this._clearCalculationMismatch(key);
       return;
@@ -6626,6 +7572,13 @@ let JupiterFormSection = class extends LitElement {
     this._calculationMismatches = next;
     this._dispatchCalculationMismatchChanged(key, detail);
   }
+  _dispatchCalculationTotalAutoPopulated(conceptId, columnId, value) {
+    this.dispatchEvent(new CustomEvent("calculation-total-auto-populated", {
+      detail: { conceptId, columnId, value, sectionId: this.section.id },
+      bubbles: true,
+      composed: true
+    }));
+  }
   _clearCalculationMismatch(key) {
     if (!this._calculationMismatches.has(key))
       return;
@@ -6689,7 +7642,7 @@ let JupiterFormSection = class extends LitElement {
     return { calculatedSum, hasAnyValue, breakdown };
   }
   static _checkTotal(totalValue, calculatedSum) {
-    return Math.abs(calculatedSum - totalValue) < 0.01;
+    return Math.abs(calculatedSum - totalValue) < CALCULATION_TOLERANCE;
   }
   static _formatNumber(n3) {
     return Number.isInteger(n3) ? String(n3) : n3.toFixed(2);
@@ -7275,123 +8228,126 @@ JupiterFormSection.styles = css`
       font-style: italic;
     }
   `;
-__decorateClass$3([
+__decorateClass$4([
   n2({ type: Object })
 ], JupiterFormSection.prototype, "section", 2);
-__decorateClass$3([
+__decorateClass$4([
   n2({ type: Array })
 ], JupiterFormSection.prototype, "columns", 2);
-__decorateClass$3([
+__decorateClass$4([
   n2({ type: Array })
 ], JupiterFormSection.prototype, "datatypes", 2);
-__decorateClass$3([
+__decorateClass$4([
   n2({ type: Object })
 ], JupiterFormSection.prototype, "formData", 2);
-__decorateClass$3([
+__decorateClass$4([
   n2({ type: Object })
 ], JupiterFormSection.prototype, "periodData", 2);
-__decorateClass$3([
+__decorateClass$4([
   n2({ type: Object })
 ], JupiterFormSection.prototype, "unitData", 2);
-__decorateClass$3([
+__decorateClass$4([
   n2({ type: Object })
 ], JupiterFormSection.prototype, "decimalsData", 2);
-__decorateClass$3([
+__decorateClass$4([
   n2({ type: String })
 ], JupiterFormSection.prototype, "globalDecimals", 2);
-__decorateClass$3([
+__decorateClass$4([
   n2({ type: Object })
 ], JupiterFormSection.prototype, "typedMemberData", 2);
-__decorateClass$3([
+__decorateClass$4([
   n2({ type: Object })
 ], JupiterFormSection.prototype, "repeatCounts", 2);
-__decorateClass$3([
+__decorateClass$4([
   n2({ type: Array })
 ], JupiterFormSection.prototype, "defaultUnits", 2);
-__decorateClass$3([
+__decorateClass$4([
   n2({ type: Boolean })
 ], JupiterFormSection.prototype, "disabled", 2);
-__decorateClass$3([
+__decorateClass$4([
   n2({ type: Boolean })
 ], JupiterFormSection.prototype, "collapsible", 2);
-__decorateClass$3([
+__decorateClass$4([
   n2({ type: String })
 ], JupiterFormSection.prototype, "locale", 2);
-__decorateClass$3([
+__decorateClass$4([
   n2({ type: Boolean })
 ], JupiterFormSection.prototype, "isFirstSection", 2);
-__decorateClass$3([
+__decorateClass$4([
   n2({ type: Array })
 ], JupiterFormSection.prototype, "availableDimensions", 2);
-__decorateClass$3([
+__decorateClass$4([
   n2({ type: Boolean })
 ], JupiterFormSection.prototype, "hideHeader", 2);
-__decorateClass$3([
+__decorateClass$4([
   n2({ type: String })
 ], JupiterFormSection.prototype, "mode", 2);
-__decorateClass$3([
+__decorateClass$4([
   n2({ type: Boolean })
 ], JupiterFormSection.prototype, "showFactsOnly", 2);
-__decorateClass$3([
+__decorateClass$4([
   n2({ type: Object })
 ], JupiterFormSection.prototype, "conceptMatchIds", 2);
-__decorateClass$3([
+__decorateClass$4([
   n2({ type: Object })
 ], JupiterFormSection.prototype, "masterData", 2);
-__decorateClass$3([
+__decorateClass$4([
   n2({ type: String })
 ], JupiterFormSection.prototype, "periodStartDate", 2);
-__decorateClass$3([
+__decorateClass$4([
   n2({ type: String })
 ], JupiterFormSection.prototype, "periodEndDate", 2);
-__decorateClass$3([
+__decorateClass$4([
   n2({ type: String })
 ], JupiterFormSection.prototype, "language", 2);
-__decorateClass$3([
+__decorateClass$4([
   n2({ type: Boolean })
 ], JupiterFormSection.prototype, "calculationEnabled", 2);
-__decorateClass$3([
+__decorateClass$4([
+  n2({ type: Object })
+], JupiterFormSection.prototype, "totalManuallyEditedData", 2);
+__decorateClass$4([
   r()
 ], JupiterFormSection.prototype, "_expanded", 2);
-__decorateClass$3([
+__decorateClass$4([
   r()
 ], JupiterFormSection.prototype, "_showAddColumnDialog", 2);
-__decorateClass$3([
+__decorateClass$4([
   r()
 ], JupiterFormSection.prototype, "_sectionPeriodType", 2);
-__decorateClass$3([
+__decorateClass$4([
   r()
 ], JupiterFormSection.prototype, "_openMenuColumnId", 2);
-__decorateClass$3([
+__decorateClass$4([
   r()
 ], JupiterFormSection.prototype, "_insertAfterColumnId", 2);
-__decorateClass$3([
+__decorateClass$4([
   r()
 ], JupiterFormSection.prototype, "_expandedConcepts", 2);
-__decorateClass$3([
+__decorateClass$4([
   r()
 ], JupiterFormSection.prototype, "_allTreeExpanded", 2);
-__decorateClass$3([
+__decorateClass$4([
   r()
 ], JupiterFormSection.prototype, "_highlightMap", 2);
-__decorateClass$3([
+__decorateClass$4([
   r()
 ], JupiterFormSection.prototype, "_focusedConceptId", 2);
-__decorateClass$3([
+__decorateClass$4([
   r()
 ], JupiterFormSection.prototype, "_calculationMismatches", 2);
-JupiterFormSection = __decorateClass$3([
+JupiterFormSection = __decorateClass$4([
   t$1("jupiter-form-section")
 ], JupiterFormSection);
-var __defProp$2 = Object.defineProperty;
-var __getOwnPropDesc$2 = Object.getOwnPropertyDescriptor;
-var __decorateClass$2 = (decorators, target, key, kind) => {
-  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$2(target, key) : target;
+var __defProp$3 = Object.defineProperty;
+var __getOwnPropDesc$3 = Object.getOwnPropertyDescriptor;
+var __decorateClass$3 = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$3(target, key) : target;
   for (var i2 = decorators.length - 1, decorator; i2 >= 0; i2--)
     if (decorator = decorators[i2])
       result = (kind ? decorator(target, key, result) : decorator(result)) || result;
   if (kind && result)
-    __defProp$2(target, key, result);
+    __defProp$3(target, key, result);
   return result;
 };
 let JupiterAdvancedFilter = class extends LitElement {
@@ -7580,27 +8536,27 @@ JupiterAdvancedFilter.styles = css`
       color: var(--primaryTextColor, var(--jupiter-text-primary, #333));
     }
   `;
-__decorateClass$2([
+__decorateClass$3([
   n2({ type: Boolean })
 ], JupiterAdvancedFilter.prototype, "showFactsOnly", 2);
-__decorateClass$2([
+__decorateClass$3([
   n2({ type: String })
 ], JupiterAdvancedFilter.prototype, "conceptSearchText", 2);
-__decorateClass$2([
+__decorateClass$3([
   r()
 ], JupiterAdvancedFilter.prototype, "_localConceptSearchText", 2);
-JupiterAdvancedFilter = __decorateClass$2([
+JupiterAdvancedFilter = __decorateClass$3([
   t$1("jupiter-advanced-filter")
 ], JupiterAdvancedFilter);
-var __defProp$1 = Object.defineProperty;
-var __getOwnPropDesc$1 = Object.getOwnPropertyDescriptor;
-var __decorateClass$1 = (decorators, target, key, kind) => {
-  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$1(target, key) : target;
+var __defProp$2 = Object.defineProperty;
+var __getOwnPropDesc$2 = Object.getOwnPropertyDescriptor;
+var __decorateClass$2 = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$2(target, key) : target;
   for (var i2 = decorators.length - 1, decorator; i2 >= 0; i2--)
     if (decorator = decorators[i2])
       result = (kind ? decorator(target, key, result) : decorator(result)) || result;
   if (kind && result)
-    __defProp$1(target, key, result);
+    __defProp$2(target, key, result);
   return result;
 };
 let _lastViewWasAdvancedFilter = false;
@@ -9217,162 +10173,539 @@ JupiterFilterRolesDialog.styles = css`
       border-color: var(--jupiter-primary-color, #1976d2);
     }
 
-    .picklist-item.selected {
-      background: var(--jupiter-primary-color, #1976d2);
-      color: white;
-      border-color: var(--jupiter-primary-color, #1976d2);
+    .picklist-item.selected {
+      background: var(--jupiter-primary-color, #1976d2);
+      color: white;
+      border-color: var(--jupiter-primary-color, #1976d2);
+    }
+
+    .picklist-item.dragging {
+      opacity: 0.5;
+      cursor: move;
+    }
+
+    .picklist-item.drag-over {
+      border-top: 3px solid var(--jupiter-primary-color, #1976d2);
+      margin-top: 3px;
+    }
+
+    .picklist-item[draggable="true"] {
+      cursor: move;
+    }
+
+    .picklist-item-label {
+      font-weight: 500;
+      font-size: 14px;
+      margin-bottom: 4px;
+    }
+
+    .picklist-item-value {
+      font-size: 11px;
+      opacity: 0.8;
+      word-break: break-all;
+    }
+
+    .picklist-controls {
+      display: flex;
+      flex-direction: column;
+      justify-content: center;
+      gap: 8px;
+      padding: 0 8px;
+    }
+
+    .picklist-button {
+      background: var(--jupiter-primary-color, #1976d2);
+      color: white;
+      border: none;
+      padding: 8px 16px;
+      border-radius: 4px;
+      cursor: pointer;
+      font-size: 14px;
+      transition: background-color 0.2s ease;
+    }
+
+    .picklist-button:hover:not(:disabled) {
+      background: var(--jupiter-primary-color-dark, #1565c0);
+    }
+
+    .picklist-button:disabled {
+      opacity: 0.4;
+      cursor: not-allowed;
+    }
+
+    .picklist-count {
+      padding: 8px 12px;
+      font-size: 12px;
+      color: var(--jupiter-text-secondary, #666);
+      background: var(--jupiter-background-light, #f8f9fa);
+      border-top: 1px solid var(--jupiter-border-color, #ddd);
+      text-align: center;
+    }
+
+    .btn-text {
+      background: none;
+      border: none;
+      color: var(--buttonBgColor, var(--jupiter-primary-color, #1976d2));
+      padding: 10px 8px;
+      font-size: 14px;
+      font-weight: 500;
+      font-family: inherit;
+      cursor: pointer;
+      margin-right: auto;
+      border-radius: 4px;
+      transition: background-color 0.2s ease;
+    }
+
+    .btn-text:hover {
+      background: var(--menuBgColorLighter, var(--jupiter-hover-background, #f5f5f5));
+    }
+  `;
+__decorateClass$2([
+  n2({ type: Boolean, reflect: true })
+], JupiterFilterRolesDialog.prototype, "open", 2);
+__decorateClass$2([
+  n2({ type: Array })
+], JupiterFilterRolesDialog.prototype, "availableRoles", 2);
+__decorateClass$2([
+  n2({ type: Array })
+], JupiterFilterRolesDialog.prototype, "selectedRoleIds", 2);
+__decorateClass$2([
+  n2({ type: Object })
+], JupiterFilterRolesDialog.prototype, "periodPreferences", 2);
+__decorateClass$2([
+  n2({ type: String })
+], JupiterFilterRolesDialog.prototype, "mode", 2);
+__decorateClass$2([
+  n2({ type: Object })
+], JupiterFilterRolesDialog.prototype, "hypercubeData", 2);
+__decorateClass$2([
+  n2({ type: Boolean })
+], JupiterFilterRolesDialog.prototype, "showFactsOnly", 2);
+__decorateClass$2([
+  n2({ type: String })
+], JupiterFilterRolesDialog.prototype, "conceptSearchText", 2);
+__decorateClass$2([
+  r()
+], JupiterFilterRolesDialog.prototype, "_tempSelectedRoles", 2);
+__decorateClass$2([
+  r()
+], JupiterFilterRolesDialog.prototype, "_searchQuery", 2);
+__decorateClass$2([
+  r()
+], JupiterFilterRolesDialog.prototype, "_filteredRoles", 2);
+__decorateClass$2([
+  r()
+], JupiterFilterRolesDialog.prototype, "_tempPeriodPreferences", 2);
+__decorateClass$2([
+  r()
+], JupiterFilterRolesDialog.prototype, "_selectedAvailableRole", 2);
+__decorateClass$2([
+  r()
+], JupiterFilterRolesDialog.prototype, "_selectedChosenRole", 2);
+__decorateClass$2([
+  r()
+], JupiterFilterRolesDialog.prototype, "_chosenSearchQuery", 2);
+__decorateClass$2([
+  r()
+], JupiterFilterRolesDialog.prototype, "_draggedRoleId", 2);
+__decorateClass$2([
+  r()
+], JupiterFilterRolesDialog.prototype, "_dragOverRoleId", 2);
+__decorateClass$2([
+  r()
+], JupiterFilterRolesDialog.prototype, "_chosenRoleOrder", 2);
+__decorateClass$2([
+  r()
+], JupiterFilterRolesDialog.prototype, "_showAdvancedFilter", 2);
+__decorateClass$2([
+  r()
+], JupiterFilterRolesDialog.prototype, "_showFactsOnly", 2);
+__decorateClass$2([
+  r()
+], JupiterFilterRolesDialog.prototype, "_conceptSearchText", 2);
+__decorateClass$2([
+  r()
+], JupiterFilterRolesDialog.prototype, "_collapsedRoles", 2);
+JupiterFilterRolesDialog = __decorateClass$2([
+  t$1("jupiter-filter-roles-dialog")
+], JupiterFilterRolesDialog);
+var __defProp$1 = Object.defineProperty;
+var __getOwnPropDesc$1 = Object.getOwnPropertyDescriptor;
+var __decorateClass$1 = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$1(target, key) : target;
+  for (var i2 = decorators.length - 1, decorator; i2 >= 0; i2--)
+    if (decorator = decorators[i2])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result)
+    __defProp$1(target, key, result);
+  return result;
+};
+let JupiterFormulaValidationDialog = class extends LitElement {
+  constructor() {
+    super(...arguments);
+    this.results = [];
+    this.open = false;
+    this._collapsedGroups = /* @__PURE__ */ new Set();
+    this._boundHandleKeydown = this._handleKeydown.bind(this);
+  }
+  connectedCallback() {
+    super.connectedCallback();
+    window.addEventListener("keydown", this._boundHandleKeydown);
+  }
+  disconnectedCallback() {
+    window.removeEventListener("keydown", this._boundHandleKeydown);
+    super.disconnectedCallback();
+  }
+  _handleKeydown(event) {
+    if (this.open && event.key === "Escape") {
+      this._handleClose();
+    }
+  }
+  _handleClose() {
+    this.open = false;
+    this.dispatchEvent(new CustomEvent("dialog-cancel", { bubbles: true }));
+  }
+  _toggleGroup(roleLabel) {
+    if (this._collapsedGroups.has(roleLabel)) {
+      this._collapsedGroups.delete(roleLabel);
+    } else {
+      this._collapsedGroups.add(roleLabel);
+    }
+    this.requestUpdate();
+  }
+  // JDF-059: navigates the host form to the exact fact this assertion's variable resolved to
+  // (or its empty target cell, for a "must exist" failure) and closes this dialog, mirroring the
+  // existing "click a validation error, land on its field" flow this feature deliberately reuses
+  // rather than building a second focus mechanism.
+  _handleConceptLinkClick(link) {
+    this.dispatchEvent(new CustomEvent("formula-concept-click", {
+      detail: { conceptId: link.conceptId, conceptQName: link.conceptQName, columnId: link.columnId },
+      bubbles: true,
+      composed: true
+    }));
+  }
+  // Splits a message on its backtick-quoted concept mentions and renders the ones this
+  // assertion resolved a fact location for (`result.conceptLinks`) as click-to-focus buttons;
+  // any other backtick mention (e.g. an enumerated value like `Na`, not a concept) renders as
+  // plain text with the backticks dropped, since there is nothing to link it to.
+  _renderMessage(result) {
+    const message = result.message ?? "";
+    const linkByLabel = new Map((result.conceptLinks ?? []).map((link) => [link.label, link]));
+    const parts = message.split(/(`[^`]+`)/g);
+    return html`${parts.map((part) => {
+      const match = /^`([^`]+)`$/.exec(part);
+      if (!match)
+        return part;
+      const link = linkByLabel.get(match[1]);
+      if (!link)
+        return match[1];
+      return html`<button type="button" class="concept-link" @click="${() => this._handleConceptLinkClick(link)}">${match[1]}</button>`;
+    })}`;
+  }
+  _groupByRole(failures) {
+    const grouped = failures.reduce((groups, result) => {
+      var _a;
+      (groups[_a = result.roleLabel] ?? (groups[_a] = [])).push(result);
+      return groups;
+    }, {});
+    return Object.entries(grouped);
+  }
+  render() {
+    if (!this.open)
+      return html``;
+    const failures = this.results.filter((result) => !result.skipped && !result.satisfied);
+    const groups = this._groupByRole(failures);
+    const summary = this.summary;
+    return html`
+      <div class="dialog" @click="${(e2) => e2.stopPropagation()}">
+        <div class="dialog-header">
+          <h2 class="dialog-title">${I18n.t("formulaValidation.dialogTitle")}</h2>
+          ${summary ? html`
+            <p class="dialog-summary">
+              ${I18n.t("formulaValidation.summaryCount", { failed: summary.failed, total: summary.totalAssertions })}
+              ${summary.failed > 0 ? html`— ${I18n.t("formulaValidation.summaryCountBreakdown", { warnings: summary.failedWarnings, errors: summary.failedErrors })}` : ""}
+            </p>
+          ` : ""}
+        </div>
+
+        <div class="dialog-content">
+          ${failures.length === 0 ? html`
+            <div class="all-passed">
+              <div class="all-passed-icon">✓</div>
+              <div class="all-passed-text">${I18n.t("formulaValidation.allPassed")}</div>
+            </div>
+          ` : groups.map(([roleLabel, rows]) => {
+      const collapsed = this._collapsedGroups.has(roleLabel);
+      return html`
+              <div class="role-group">
+                <div class="role-group-header" @click="${() => this._toggleGroup(roleLabel)}">
+                  <span class="role-group-title">${roleLabel}</span>
+                  <span class="role-group-count">${rows.length}</span>
+                  <button class="role-group-toggle" type="button">${collapsed ? "▸" : "▾"}</button>
+                </div>
+                ${collapsed ? "" : html`
+                  <div class="role-group-rows">
+                    ${rows.map((result) => html`
+                      <div class="assertion-row">
+                        <span class="severity-badge ${result.severity === "ERROR" ? "error" : "warning"}">
+                          ${result.severity === "ERROR" ? I18n.t("formulaValidation.severityError") : I18n.t("formulaValidation.severityWarning")}
+                        </span>
+                        <span class="assertion-message">${this._renderMessage(result)}</span>
+                      </div>
+                    `)}
+                  </div>
+                `}
+              </div>
+            `;
+    })}
+        </div>
+
+        <div class="dialog-actions">
+          <button class="btn btn-primary" @click="${this._handleClose}">
+            ${I18n.t("formulaValidation.close")}
+          </button>
+        </div>
+      </div>
+    `;
+  }
+};
+JupiterFormulaValidationDialog.styles = css`
+    :host {
+      position: fixed;
+      top: 0;
+      left: 0;
+      width: 100%;
+      height: 100%;
+      background: rgba(0, 0, 0, 0.5);
+      z-index: 1100;
+      display: flex;
+      align-items: center;
+      justify-content: center;
+      opacity: 0;
+      visibility: hidden;
+      transition: opacity 0.3s ease, visibility 0.3s ease;
+    }
+
+    :host([open]) {
+      opacity: 1;
+      visibility: visible;
+    }
+
+    .dialog {
+      background: var(--bg-color-2, var(--jupiter-card-background, #fff));
+      border-radius: 8px;
+      padding: 24px;
+      min-width: 420px;
+      max-width: 640px;
+      width: 90vw;
+      max-height: 90vh;
+      box-shadow: 0 10px 30px rgba(0, 0, 0, 0.3);
+      transform: scale(0.9);
+      transition: transform 0.3s ease;
+      display: flex;
+      flex-direction: column;
+    }
+
+    :host([open]) .dialog {
+      transform: scale(1);
+    }
+
+    .dialog-header {
+      margin-bottom: 16px;
+      flex-shrink: 0;
+    }
+
+    .dialog-title {
+      font-size: 20px;
+      font-weight: 600;
+      color: var(--primaryTextColor, var(--jupiter-text-primary, #333));
+      margin: 0 0 8px 0;
+    }
+
+    .dialog-summary {
+      font-size: 14px;
+      color: var(--jupiter-text-secondary, #666);
+      margin: 0;
+    }
+
+    /* JDF-035 dialog-overflow fix: min-height: 0 is required on a flex-column scrollable child,
+       otherwise the browser lets it grow past the dialog's max-height instead of scrolling. */
+    .dialog-content {
+      margin-bottom: 20px;
+      flex: 1;
+      overflow-y: auto;
+      min-height: 0;
+    }
+
+    .all-passed {
+      display: flex;
+      flex-direction: column;
+      align-items: center;
+      gap: 12px;
+      padding: 32px 16px;
+      color: var(--jupiter-text-primary, #333);
+    }
+
+    .all-passed-icon {
+      width: 40px;
+      height: 40px;
+      border-radius: 50%;
+      background: var(--jupiter-success-color, #4caf50);
+      color: #fff;
+      display: flex;
+      align-items: center;
+      justify-content: center;
+      font-size: 22px;
+      font-weight: 700;
+    }
+
+    .all-passed-text {
+      font-size: 15px;
+      font-weight: 500;
+    }
+
+    .role-group {
+      border: 1px solid var(--jupiter-border-color, #ddd);
+      border-radius: 4px;
+      margin-bottom: 12px;
+      overflow: hidden;
+    }
+
+    .role-group-header {
+      display: flex;
+      align-items: center;
+      justify-content: space-between;
+      gap: 8px;
+      padding: 10px 12px;
+      background: var(--jupiter-card-background, #fafafa);
+      cursor: pointer;
+      user-select: none;
+    }
+
+    .role-group-title {
+      font-weight: 600;
+      font-size: 14px;
+      color: var(--primaryTextColor, var(--jupiter-text-primary, #333));
+    }
+
+    .role-group-count {
+      font-size: 12px;
+      color: var(--jupiter-text-secondary, #666);
+    }
+
+    .role-group-toggle {
+      background: none;
+      border: none;
+      cursor: pointer;
+      font-size: 12px;
+      color: var(--jupiter-text-secondary, #666);
+      padding: 0 4px;
     }
 
-    .picklist-item.dragging {
-      opacity: 0.5;
-      cursor: move;
+    .role-group-rows {
+      padding: 4px 12px 8px 12px;
     }
 
-    .picklist-item.drag-over {
-      border-top: 3px solid var(--jupiter-primary-color, #1976d2);
-      margin-top: 3px;
+    .assertion-row {
+      display: flex;
+      align-items: flex-start;
+      gap: 8px;
+      padding: 8px 0;
+      border-top: 1px solid var(--jupiter-border-color, #eee);
     }
 
-    .picklist-item[draggable="true"] {
-      cursor: move;
+    .assertion-row:first-child {
+      border-top: none;
     }
 
-    .picklist-item-label {
-      font-weight: 500;
-      font-size: 14px;
-      margin-bottom: 4px;
+    .severity-badge {
+      flex-shrink: 0;
+      display: inline-flex;
+      align-items: center;
+      gap: 4px;
+      padding: 2px 8px;
+      border-radius: 10px;
+      font-size: 11px;
+      font-weight: 700;
+      color: #fff;
+      white-space: nowrap;
     }
 
-    .picklist-item-value {
-      font-size: 11px;
-      opacity: 0.8;
-      word-break: break-all;
+    .severity-badge.warning {
+      background: var(--jupiter-warning-color, #ff9800);
     }
 
-    .picklist-controls {
-      display: flex;
-      flex-direction: column;
-      justify-content: center;
-      gap: 8px;
-      padding: 0 8px;
+    .severity-badge.error {
+      background: var(--jupiter-error-color, #d32f2f);
     }
 
-    .picklist-button {
-      background: var(--jupiter-primary-color, #1976d2);
-      color: white;
-      border: none;
-      padding: 8px 16px;
-      border-radius: 4px;
-      cursor: pointer;
-      font-size: 14px;
-      transition: background-color 0.2s ease;
+    .assertion-message {
+      font-size: 13px;
+      color: var(--primaryTextColor, var(--jupiter-text-primary, #333));
+      line-height: 1.4;
     }
 
-    .picklist-button:hover:not(:disabled) {
-      background: var(--jupiter-primary-color-dark, #1565c0);
+    .concept-link {
+      font: inherit;
+      font-weight: 600;
+      color: var(--buttonBgColor, var(--jupiter-primary-color, #1976d2));
+      background: none;
+      border: none;
+      padding: 0;
+      margin: 0;
+      cursor: pointer;
+      text-decoration: underline;
+      text-underline-offset: 2px;
     }
 
-    .picklist-button:disabled {
-      opacity: 0.4;
-      cursor: not-allowed;
+    .concept-link:hover {
+      opacity: 0.8;
     }
 
-    .picklist-count {
-      padding: 8px 12px;
-      font-size: 12px;
-      color: var(--jupiter-text-secondary, #666);
-      background: var(--jupiter-background-light, #f8f9fa);
+    .dialog-actions {
+      display: flex;
+      gap: 12px;
+      justify-content: flex-end;
+      flex-shrink: 0;
       border-top: 1px solid var(--jupiter-border-color, #ddd);
-      text-align: center;
+      padding-top: 16px;
+      margin-top: 16px;
     }
 
-    .btn-text {
-      background: none;
+    .btn {
+      padding: 10px 20px;
       border: none;
-      color: var(--buttonBgColor, var(--jupiter-primary-color, #1976d2));
-      padding: 10px 8px;
+      border-radius: 4px;
       font-size: 14px;
       font-weight: 500;
-      font-family: inherit;
       cursor: pointer;
-      margin-right: auto;
-      border-radius: 4px;
       transition: background-color 0.2s ease;
     }
 
-    .btn-text:hover {
-      background: var(--menuBgColorLighter, var(--jupiter-hover-background, #f5f5f5));
+    .btn-primary {
+      background: var(--buttonBgColor, var(--jupiter-primary-color, #1976d2));
+      color: var(--buttonTextColor, white);
+    }
+
+    .btn-primary:hover {
+      opacity: 0.9;
     }
   `;
-__decorateClass$1([
-  n2({ type: Boolean, reflect: true })
-], JupiterFilterRolesDialog.prototype, "open", 2);
-__decorateClass$1([
-  n2({ type: Array })
-], JupiterFilterRolesDialog.prototype, "availableRoles", 2);
 __decorateClass$1([
   n2({ type: Array })
-], JupiterFilterRolesDialog.prototype, "selectedRoleIds", 2);
-__decorateClass$1([
-  n2({ type: Object })
-], JupiterFilterRolesDialog.prototype, "periodPreferences", 2);
-__decorateClass$1([
-  n2({ type: String })
-], JupiterFilterRolesDialog.prototype, "mode", 2);
+], JupiterFormulaValidationDialog.prototype, "results", 2);
 __decorateClass$1([
   n2({ type: Object })
-], JupiterFilterRolesDialog.prototype, "hypercubeData", 2);
-__decorateClass$1([
-  n2({ type: Boolean })
-], JupiterFilterRolesDialog.prototype, "showFactsOnly", 2);
-__decorateClass$1([
-  n2({ type: String })
-], JupiterFilterRolesDialog.prototype, "conceptSearchText", 2);
-__decorateClass$1([
-  r()
-], JupiterFilterRolesDialog.prototype, "_tempSelectedRoles", 2);
-__decorateClass$1([
-  r()
-], JupiterFilterRolesDialog.prototype, "_searchQuery", 2);
-__decorateClass$1([
-  r()
-], JupiterFilterRolesDialog.prototype, "_filteredRoles", 2);
-__decorateClass$1([
-  r()
-], JupiterFilterRolesDialog.prototype, "_tempPeriodPreferences", 2);
-__decorateClass$1([
-  r()
-], JupiterFilterRolesDialog.prototype, "_selectedAvailableRole", 2);
-__decorateClass$1([
-  r()
-], JupiterFilterRolesDialog.prototype, "_selectedChosenRole", 2);
-__decorateClass$1([
-  r()
-], JupiterFilterRolesDialog.prototype, "_chosenSearchQuery", 2);
-__decorateClass$1([
-  r()
-], JupiterFilterRolesDialog.prototype, "_draggedRoleId", 2);
-__decorateClass$1([
-  r()
-], JupiterFilterRolesDialog.prototype, "_dragOverRoleId", 2);
-__decorateClass$1([
-  r()
-], JupiterFilterRolesDialog.prototype, "_chosenRoleOrder", 2);
-__decorateClass$1([
-  r()
-], JupiterFilterRolesDialog.prototype, "_showAdvancedFilter", 2);
-__decorateClass$1([
-  r()
-], JupiterFilterRolesDialog.prototype, "_showFactsOnly", 2);
+], JupiterFormulaValidationDialog.prototype, "summary", 2);
 __decorateClass$1([
-  r()
-], JupiterFilterRolesDialog.prototype, "_conceptSearchText", 2);
+  n2({ type: Boolean, reflect: true })
+], JupiterFormulaValidationDialog.prototype, "open", 2);
 __decorateClass$1([
   r()
-], JupiterFilterRolesDialog.prototype, "_collapsedRoles", 2);
-JupiterFilterRolesDialog = __decorateClass$1([
-  t$1("jupiter-filter-roles-dialog")
-], JupiterFilterRolesDialog);
+], JupiterFormulaValidationDialog.prototype, "_collapsedGroups", 2);
+JupiterFormulaValidationDialog = __decorateClass$1([
+  t$1("jupiter-formula-validation-dialog")
+], JupiterFormulaValidationDialog);
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __decorateClass = (decorators, target, key, kind) => {
@@ -9392,6 +10725,7 @@ let JupiterDynamicForm = class extends LitElement {
     this.disabled = false;
     this.readonly = false;
     this.calculationEnabled = false;
+    this.formulaEnabled = false;
     this.periodStartDate = "2025-01-01";
     this.periodEndDate = "2025-12-31";
     this.language = "en";
@@ -9411,6 +10745,7 @@ let JupiterDynamicForm = class extends LitElement {
     this._unitData = {};
     this._preservedUnitData = {};
     this._decimalsData = {};
+    this._totalManuallyEditedData = {};
     this._effectiveMasterData = void 0;
     this._typedMemberData = {};
     this._preservedTypedMemberData = {};
@@ -9443,6 +10778,9 @@ let JupiterDynamicForm = class extends LitElement {
     this._contextMenuY = 0;
     this._contextMenuRoleId = null;
     this._validationStatus = "idle";
+    this._formulaValidationResults = [];
+    this._showFormulaValidationDialog = false;
+    this._formulaValidationService = new FormulaValidationService();
     this._skipDraftLoading = false;
     this._skipPeriodPreferencesRestore = false;
     this._autoSaveTimer = null;
@@ -9474,6 +10812,24 @@ let JupiterDynamicForm = class extends LitElement {
     this.addEventListener("calculation-mismatch-changed", (e2) => {
       this._handleCalculationMismatchChanged(e2);
     });
+    this.addEventListener("total-manually-edited", (e2) => {
+      const { conceptId, columnId } = e2.detail;
+      const updated = { ...this._totalManuallyEditedData };
+      updated[conceptId] = { ...updated[conceptId], [columnId]: true };
+      this._totalManuallyEditedData = updated;
+    });
+    this.addEventListener("calculation-total-auto-populated", (e2) => {
+      const { conceptId, columnId, value } = e2.detail;
+      const oldValue = this._writeFormDataValue(conceptId, columnId, value);
+      this._touched.add(`${conceptId}-${columnId}`);
+      this._dirty = true;
+      this._validateForm();
+      this.requestUpdate();
+      this.dispatchEvent(new CustomEvent("field-change", {
+        detail: { fieldId: conceptId, conceptId, columnId, value, oldValue, source: "auto-calculated" },
+        bubbles: true
+      }));
+    });
     document.addEventListener("click", () => {
       if (this._showRoleContextMenu) {
         this._showRoleContextMenu = false;
@@ -10148,6 +11504,20 @@ let JupiterDynamicForm = class extends LitElement {
     const roleCount = this._getRoleIdsArray().length;
     console.log(`🚫 Filter dialog cancelled. Current selection: ${roleCount}/${this._allSections.length}`);
   }
+  // JDF-050: closes the formula-validation results dialog opened by JDF-049's pre-flight.
+  // Purely a visibility toggle — submit already proceeded on the click that opened it
+  // (non-blocking, per the corrected JDF-043 Q4 decision), so there is nothing to resume here.
+  _handleFormulaValidationDialogCancel() {
+    this._showFormulaValidationDialog = false;
+  }
+  // JDF-059: a concept name inside a formula-validation message was clicked — close the popup
+  // (mirrors the existing "click a validation error, land on its field" UX from the host-rendered
+  // show-validation-results flow) and jump straight to the exact fact the assertion's own variable
+  // resolution identified, via `columnId` rather than re-deriving it from dimensions.
+  _handleFormulaConceptClick(event) {
+    this._showFormulaValidationDialog = false;
+    this.scrollToConcept(event.detail.conceptQName, void 0, void 0, event.detail.columnId);
+  }
   _handleRoleFilterApply(event) {
     var _a, _b;
     const { selectedRoleIds, periodPreferences } = event.detail;
@@ -10175,7 +11545,8 @@ let JupiterDynamicForm = class extends LitElement {
       this._repeatCounts,
       this._decimalsData,
       void 0,
-      this._getHiddenColumnsForMetadata()
+      this._getHiddenColumnsForMetadata(),
+      this._totalManuallyEditedData
     );
     this._draftStorageService.saveDraft(currentFormData, currentMetadata);
     console.log("✅ Current form data saved to draft storage with NEW preferences");
@@ -10284,9 +11655,13 @@ let JupiterDynamicForm = class extends LitElement {
     this._calculationWarnings = next;
     this._validateForm();
   }
-  _handleFieldChange(event) {
-    const { fieldId, conceptId, columnId, value } = event.detail;
-    console.log(`📝 Field change: conceptId=${conceptId}, columnId=${columnId}, value=${value}, fieldId=${fieldId}`);
+  /**
+   * JDF-058: single source of truth for writing a value into `_formData` with the immutable-update
+   * pattern Lit reactivity needs — shared by a real user keystroke (`_handleFieldChange`) and the
+   * auto-populate-totals `calculation-total-auto-populated` handler, so the update logic isn't
+   * duplicated. Returns the value that was previously stored, for event `oldValue` fields.
+   */
+  _writeFormDataValue(conceptId, columnId, value) {
     const updatedFormData = { ...this._formData };
     if (!updatedFormData[conceptId]) {
       updatedFormData[conceptId] = {};
@@ -10294,6 +11669,12 @@ let JupiterDynamicForm = class extends LitElement {
     const oldValue = updatedFormData[conceptId][columnId];
     updatedFormData[conceptId] = { ...updatedFormData[conceptId], [columnId]: value };
     this._formData = updatedFormData;
+    return oldValue;
+  }
+  _handleFieldChange(event) {
+    const { fieldId, conceptId, columnId, value } = event.detail;
+    console.log(`📝 Field change: conceptId=${conceptId}, columnId=${columnId}, value=${value}, fieldId=${fieldId}`);
+    const oldValue = this._writeFormDataValue(conceptId, columnId, value);
     console.log(`💾 Updated formData[${conceptId}]:`, this._formData[conceptId]);
     this._touched.add(`${conceptId}-${columnId}`);
     this._dirty = true;
@@ -11296,6 +12677,89 @@ let JupiterDynamicForm = class extends LitElement {
       this._submitDisabled = false;
     }, 1e3);
   }
+  /**
+   * Handler for the standalone "Quick Validate" button (visible only when `formulaEnabled` is
+   * true). Runs the formula-assertion pre-flight in isolation from the original Validate/submit
+   * button, which no longer triggers formula validation as a side effect.
+   */
+  _handleQuickValidate() {
+    if (this.mode === "admin")
+      return;
+    this._runFormulaValidationPreflight();
+  }
+  /**
+   * JDF-049: runs FormulaValidationService against the live form state and stores the results
+   * for the results dialog (JDF-050). Graceful no-op — per JDF-048's gating and this ticket's
+   * "no Validate-formulas affordance/effect when formula data is absent" requirement — when
+   * `formulaEnabled` is off or `xbrlInput.formula` has no roles. Never blocks the caller; always
+   * returns before any resolution work is attempted when gated off (JDF-048's "zero evaluation
+   * cost when off" requirement).
+   */
+  _runFormulaValidationPreflight() {
+    var _a, _b, _c, _d, _e, _f, _g, _h;
+    if (!this.formulaEnabled)
+      return;
+    const formulaRoles = (_c = (_b = (_a = this.xbrlInput) == null ? void 0 : _a.formula) == null ? void 0 : _b[0]) == null ? void 0 : _c.roles;
+    if (!formulaRoles || formulaRoles.length === 0)
+      return;
+    const scopeSections = ((_e = (_d = this._currentSchema) == null ? void 0 : _d.sections) == null ? void 0 : _e.length) ? this._currentSchema.sections : this._allSections;
+    if (!scopeSections || scopeSections.length === 0)
+      return;
+    const visibleRoleURIs = new Set(scopeSections.map((section2) => {
+      var _a2;
+      return ((_a2 = section2.metadata) == null ? void 0 : _a2.roleURI) || section2.id;
+    }));
+    const scopedFormulaRoles = formulaRoles.filter((role) => visibleRoleURIs.has(role.roleURI));
+    if (scopedFormulaRoles.length === 0)
+      return;
+    const conceptSections = scopeSections.map((section2) => {
+      var _a2;
+      return {
+        roleURI: ((_a2 = section2.metadata) == null ? void 0 : _a2.roleURI) || section2.id,
+        concepts: section2.concepts
+      };
+    });
+    const ctx = buildFormulaResolutionContext(
+      this._formData,
+      this._mergeAllSectionColumns(),
+      conceptSections,
+      (_h = (_g = (_f = this.xbrlInput) == null ? void 0 : _f.hypercubes) == null ? void 0 : _g[0]) == null ? void 0 : _h.roles,
+      this.periodStartDate,
+      this.periodEndDate
+    );
+    const scopedXbrlInput = {
+      ...this.xbrlInput,
+      formula: [{ ...this.xbrlInput.formula[0], roles: scopedFormulaRoles }]
+    };
+    const results = this._formulaValidationService.evaluate(scopedXbrlInput, ctx, this.language);
+    const summary = this._formulaValidationService.summarize(results);
+    this._formulaValidationResults = results;
+    this._formulaValidationSummary = summary;
+    const hasFailures = results.some((result) => !result.skipped && !result.satisfied);
+    if (hasFailures) {
+      this._showFormulaValidationDialog = true;
+    }
+    this.dispatchEvent(new CustomEvent("formula-validation-complete", {
+      detail: { results, summary },
+      bubbles: true,
+      composed: true
+    }));
+  }
+  /**
+   * Formula assertions can reference concepts/dimensions from any disclosure role, but
+   * `FormColumn`s (especially dimension columns) are tracked per-section (`section.columns`),
+   * with `this._columns` as the shared/default fallback (see the pattern at L1398/L2814/L5284).
+   * `_formData` itself is already global (keyed by conceptId/columnId, no section nesting), so a
+   * single merged, deduplicated-by-id column list is the correct match for it.
+   */
+  _mergeAllSectionColumns() {
+    const merged = /* @__PURE__ */ new Map();
+    this._columns.forEach((column2) => merged.set(column2.id, column2));
+    this._allSections.forEach((section2) => {
+      (section2.columns || []).forEach((column2) => merged.set(column2.id, column2));
+    });
+    return Array.from(merged.values());
+  }
   _handleSaveDraft(source = "manual") {
     console.log(`🔵 [Save Draft] Checking for errors...`);
     console.log(`🔵 [Save Draft] _xbrlFormErrors.length: ${this._xbrlFormErrors.length}`);
@@ -11333,7 +12797,8 @@ let JupiterDynamicForm = class extends LitElement {
       this._repeatCounts,
       this._decimalsData,
       roleCompletedStates,
-      this._getHiddenColumnsForMetadata()
+      this._getHiddenColumnsForMetadata(),
+      this._totalManuallyEditedData
     );
     const draftPayloadSnapshot = JSON.stringify({
       draftData,
@@ -11475,6 +12940,10 @@ let JupiterDynamicForm = class extends LitElement {
       );
       console.log("🔄 Restored hidden columns for", this._hiddenColumnIds.size, "sections");
     }
+    if (metadata.totalManuallyEditedData) {
+      this._totalManuallyEditedData = metadata.totalManuallyEditedData;
+      console.log("🔄 Restored total manually-edited data:", Object.keys(this._totalManuallyEditedData).length, "concepts");
+    }
     if (metadata.periodPreferences) {
       if (this._skipPeriodPreferencesRestore) {
         console.log("⏭️ Skipping period preferences restoration - using new filter selections");
@@ -11554,6 +13023,7 @@ let JupiterDynamicForm = class extends LitElement {
     });
     this._formData = { ...this._formData, ...restoredFormData };
     console.log(`🔄 Restored ${Object.keys(restoredFormData).length} concepts with data`);
+    this._seedLegacyManuallyEditedTotals(restoredFormData);
     this._initializeGlobalDecimalsFromRoundingData();
     this._periodData = {
       ...this._periodData,
@@ -11687,6 +13157,47 @@ let JupiterDynamicForm = class extends LitElement {
     });
     console.log(`✅ Field population complete: ${populatedCount} populated, ${notFoundCount} not found`);
   }
+  /**
+   * JDF-058: seed the manual-edit dirty flag for any total whose value predates this feature, so
+   * upgrading never silently recomputes a customer's pre-existing, already-filed totals. Walks
+   * `_allSections` (the full pool, including currently-hidden/filtered-out sections — a hidden
+   * total's pre-existing value must stay protected the moment its section becomes visible again),
+   * not just the currently-selected roles. Idempotent: only seeds a cell that has no explicit
+   * `totalManuallyEditedData` entry already (i.e. `metadata.totalManuallyEditedData` didn't cover
+   * it), so re-running on an already-seeded draft is a no-op. Does not touch `restoredFormData`.
+   */
+  _seedLegacyManuallyEditedTotals(restoredFormData) {
+    const seeded = { ...this._totalManuallyEditedData };
+    let changed = false;
+    const walk = (concepts) => {
+      var _a;
+      for (const concept of concepts) {
+        if (isTotalLabel$1(concept.preferredLabel)) {
+          const values = restoredFormData[concept.id];
+          if (values) {
+            for (const columnId of Object.keys(values)) {
+              const value = values[columnId];
+              const isBlank = value === null || value === void 0 || value === "";
+              if (!isBlank && ((_a = seeded[concept.id]) == null ? void 0 : _a[columnId]) === void 0) {
+                seeded[concept.id] = { ...seeded[concept.id] || {}, [columnId]: true };
+                changed = true;
+              }
+            }
+          }
+        }
+        if (concept.children && concept.children.length > 0) {
+          walk(concept.children);
+        }
+      }
+    };
+    for (const section2 of this._allSections) {
+      walk(section2.concepts || []);
+    }
+    if (changed) {
+      this._totalManuallyEditedData = seeded;
+      console.log("🔒 [JDF-058] Seeded manual-edit protection for pre-existing total values in legacy draft");
+    }
+  }
   _restoreCustomColumns(customColumns) {
     const columnsBySection = /* @__PURE__ */ new Map();
     customColumns.forEach((col) => {
@@ -13136,6 +14647,7 @@ let JupiterDynamicForm = class extends LitElement {
             .periodStartDate="${this.periodStartDate}"
             .periodEndDate="${this.periodEndDate}"
             .calculationEnabled="${this.calculationEnabled}"
+            .totalManuallyEditedData="${this._totalManuallyEditedData}"
             @field-change="${this._handleFieldChange}"
             @period-change="${this._handlePeriodChange}"
             @typed-member-change="${this._handleTypedMemberChange}"
@@ -13284,6 +14796,7 @@ let JupiterDynamicForm = class extends LitElement {
                 .periodStartDate="${this.periodStartDate}"
                 .periodEndDate="${this.periodEndDate}"
                 .calculationEnabled="${this.calculationEnabled}"
+                .totalManuallyEditedData="${this._totalManuallyEditedData}"
                 @field-change="${this._handleFieldChange}"
                 @typed-member-change="${this._handleTypedMemberChange}"
                 @add-concept-repeat="${this._handleAddConceptRepeat}"
@@ -13382,9 +14895,9 @@ let JupiterDynamicForm = class extends LitElement {
       return dims.length === 1 && this._normalizeAxisId(col.dimensionData.axisId ?? "") === this._normalizeAxisId(dims[0].axis) && this._normalizeMemberId(col.dimensionData.memberId ?? "") === this._normalizeMemberId(dims[0].member);
     })) == null ? void 0 : _a.id;
   }
-  async scrollToConcept(conceptName, dimensions, match) {
+  async scrollToConcept(conceptName, dimensions, match, columnId) {
     var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l;
-    console.log(`[scrollToConcept] ▶ START conceptName=${conceptName} value=${match == null ? void 0 : match.value} dims=${JSON.stringify(dimensions)}`);
+    console.log(`[scrollToConcept] ▶ START conceptName=${conceptName} value=${match == null ? void 0 : match.value} dims=${JSON.stringify(dimensions)} columnId=${columnId}`);
     let targetSection = null;
     let targetConcept = null;
     const sectionsToSearch = [
@@ -13398,7 +14911,19 @@ let JupiterDynamicForm = class extends LitElement {
     for (const section2 of sectionsToSearch) {
       const found = this._findConceptByName(section2.concepts, conceptName);
       if (found) {
-        if (dimensions == null ? void 0 : dimensions.length) {
+        if (columnId) {
+          const cols = section2.columns ?? this._columns;
+          const hasColumn = cols.some((c2) => c2.id === columnId);
+          console.log(`[scrollToConcept] Section "${section2.id}" has concept "${found.id}" | columnId="${columnId}" present=${hasColumn}`);
+          if (hasColumn) {
+            targetSection = section2;
+            targetConcept = found;
+            break;
+          } else if (!targetSection) {
+            targetSection = section2;
+            targetConcept = found;
+          }
+        } else if (dimensions == null ? void 0 : dimensions.length) {
           const cols = section2.columns ?? this._columns;
           const colId = this._findColumnByDimensions(cols, dimensions);
           console.log(`[scrollToConcept] Section "${section2.id}" has concept "${found.id}" | colMatch=${colId ?? "null"} | cols=${cols.map((c2) => c2.id).join(",")}`);
@@ -13431,7 +14956,9 @@ let JupiterDynamicForm = class extends LitElement {
     let targetColumnId = null;
     const hasValueMatch = (match == null ? void 0 : match.value) !== void 0 && (match == null ? void 0 : match.value) !== null;
     const targetValue = hasValueMatch ? String(match.value) : null;
-    if (dimensions == null ? void 0 : dimensions.length) {
+    if (columnId) {
+      targetColumnId = columnId;
+    } else if (dimensions == null ? void 0 : dimensions.length) {
       targetColumnId = this._findColumnByDimensions(columns, dimensions) ?? null;
     } else if (!hasValueMatch) {
       targetColumnId = ((_b = columns[0]) == null ? void 0 : _b.id) ?? null;
@@ -13677,6 +15204,15 @@ let JupiterDynamicForm = class extends LitElement {
             </button>
           ` : ""}
 
+          ${this.formulaEnabled && this.mode !== "admin" ? html`
+            <button
+              class="btn-secondary btn-quick-validate"
+              @click="${this._handleQuickValidate}"
+              ?disabled="${this.disabled || this.readonly || this._validationStatus === "inProgress"}"
+            >
+              ${I18n.t("form.quickValidate")}
+            </button>
+          ` : ""}
 
           <button
             class="btn-primary"
@@ -13706,7 +15242,19 @@ let JupiterDynamicForm = class extends LitElement {
             @click="${this._handleFilterDialogCancel}"
           ></jupiter-filter-roles-dialog>
         ` : ""}
-        
+
+        <!-- Formula Validation Results Dialog (JDF-050) -->
+        ${this._showFormulaValidationDialog ? html`
+          <jupiter-formula-validation-dialog
+            ?open="${this._showFormulaValidationDialog}"
+            .results="${this._formulaValidationResults}"
+            .summary="${this._formulaValidationSummary}"
+            @dialog-cancel="${this._handleFormulaValidationDialogCancel}"
+            @formula-concept-click="${this._handleFormulaConceptClick}"
+            @click="${this._handleFormulaValidationDialogCancel}"
+          ></jupiter-formula-validation-dialog>
+        ` : ""}
+
         <!-- Validation Error Popup -->
         ${this._showErrorPopup ? html`
           <div class="error-popup-overlay" @click="${() => {
@@ -14623,6 +16171,9 @@ __decorateClass([
 __decorateClass([
   n2({ type: Boolean, attribute: "calculation-enabled" })
 ], JupiterDynamicForm.prototype, "calculationEnabled", 2);
+__decorateClass([
+  n2({ type: Boolean, attribute: "formula-enabled" })
+], JupiterDynamicForm.prototype, "formulaEnabled", 2);
 __decorateClass([
   n2({ type: String })
 ], JupiterDynamicForm.prototype, "periodStartDate", 2);
@@ -14695,6 +16246,9 @@ __decorateClass([
 __decorateClass([
   r()
 ], JupiterDynamicForm.prototype, "_decimalsData", 2);
+__decorateClass([
+  r()
+], JupiterDynamicForm.prototype, "_totalManuallyEditedData", 2);
 __decorateClass([
   r()
 ], JupiterDynamicForm.prototype, "_effectiveMasterData", 2);
@@ -14794,6 +16348,15 @@ __decorateClass([
 __decorateClass([
   r()
 ], JupiterDynamicForm.prototype, "_validationStatus", 2);
+__decorateClass([
+  r()
+], JupiterDynamicForm.prototype, "_formulaValidationResults", 2);
+__decorateClass([
+  r()
+], JupiterDynamicForm.prototype, "_formulaValidationSummary", 2);
+__decorateClass([
+  r()
+], JupiterDynamicForm.prototype, "_showFormulaValidationDialog", 2);
 JupiterDynamicForm = __decorateClass([
   t$1("jupiter-dynamic-form")
 ], JupiterDynamicForm);
@@ -14808,6 +16371,7 @@ export {
   JupiterFilterRolesDialog,
   JupiterFormField,
   JupiterFormSection,
+  JupiterFormulaValidationDialog,
   TYPE_INPUT_MAP,
   XBRLValidator,
   collectEnumerationsFromChain,