jupiter-dynamic-forms 1.20.3 → 1.20.5

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",
@@ -1873,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",
@@ -2491,6 +2493,10 @@ class Parser {
       this.next();
       return { kind: "number", value: Number(token.value) };
     }
+    if (token.type === "STRING") {
+      this.next();
+      return { kind: "string", value: token.value };
+    }
     if (token.type === "VARIABLE") {
       this.next();
       return { kind: "variable", name: token.value };
@@ -2518,20 +2524,30 @@ class Parser {
 function lookup(bindings, name) {
   return bindings.get(name);
 }
-function evalSum(variable, bindings) {
+function evalSum(variable, bindings, test) {
   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;
+  const values = Array.isArray(binding) ? binding : [binding];
+  return values.reduce((total, value) => {
+    if (typeof value === "string") {
+      throw new FormulaExpressionError(
+        `Variable "$${variable}" resolved to a non-numeric value ("${value}") and cannot be used in sum(...)`,
+        test,
+        "unsupported-syntax"
+      );
+    }
+    return total + value;
+  }, 0);
 }
 function evalValue(node, bindings, test) {
   switch (node.kind) {
     case "number":
       return node.value;
+    case "string":
+      return node.value;
     case "sum":
-      return evalSum(node.variable, bindings);
+      return evalSum(node.variable, bindings, test);
     case "variable": {
       const binding = lookup(bindings, node.name);
       if (binding === void 0) {
@@ -2551,7 +2567,17 @@ function evalValue(node, bindings, test) {
       return binding;
     }
     case "additive":
-      return node.terms.reduce((total, { sign, term }) => total + sign * evalValue(term, bindings, test), 0);
+      return node.terms.reduce((total, { sign, term }) => {
+        const value = evalValue(term, bindings, test);
+        if (typeof value === "string") {
+          throw new FormulaExpressionError(
+            `Non-numeric value ("${value}") cannot be used in arithmetic (+ / -)`,
+            test,
+            "unsupported-syntax"
+          );
+        }
+        return total + sign * value;
+      }, 0);
   }
 }
 function evalBool(node, bindings, test, fallbackUsage) {
@@ -2580,6 +2606,9 @@ function evalBool(node, bindings, test, fallbackUsage) {
     case "comparison": {
       const left = evalValue(node.left, bindings, test);
       const right = evalValue(node.right, bindings, test);
+      if (typeof left === "string" || typeof right === "string") {
+        return String(left) === String(right);
+      }
       return Math.abs(left - right) < CALCULATION_TOLERANCE;
     }
   }
@@ -2715,56 +2744,74 @@ function collectAllCandidates(formData) {
   }
   return candidates;
 }
-function indexConceptTree(concept, conceptByQName, conceptById, childrenIndex) {
+function indexConceptTree(concept, conceptByQName, conceptById, conceptIdByQName, conceptIdByQNameHasChildren, childrenIndex) {
   const info = {
     conceptId: concept.id,
-    qname: concept.conceptName,
-    balance: concept.balance
+    qname: concept.name,
+    balance: concept.balance,
+    effectivePeriodRole: concept.effectivePeriodRole
   };
-  if (!conceptById.has(concept.id))
-    conceptById.set(concept.id, info);
-  if (!conceptByQName.has(concept.conceptName))
-    conceptByQName.set(concept.conceptName, info);
+  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, childrenIndex));
+  children.forEach((child) => indexConceptTree(child, conceptByQName, conceptById, conceptIdByQName, conceptIdByQNameHasChildren, childrenIndex));
 }
-function indexMemberTree(member, memberQNameToId) {
+function indexMemberTree(member, memberQNameToId, memberChildrenByQName) {
   if (!memberQNameToId.has(member.conceptName))
     memberQNameToId.set(member.conceptName, member.id);
-  (member.children || []).forEach((child) => indexMemberTree(child, memberQNameToId));
+  if (!memberChildrenByQName.has(member.conceptName)) {
+    memberChildrenByQName.set(member.conceptName, (member.children || []).map((child) => child.id));
+  }
+  (member.children || []).forEach((child) => indexMemberTree(child, memberQNameToId, memberChildrenByQName));
 }
 const PRESENTATION_TOTAL_GROUP_ACCESSORS = {
   getId: (concept) => concept.id,
   getPreferredLabel: (concept) => concept.preferredLabel,
-  isAbstract: (concept) => concept.elementAbstract,
+  isAbstract: (concept) => concept.abstract === true,
   getChildren: (concept) => concept.children || []
 };
-function buildFormulaResolutionContext(formData, columns, presentationRoles, hypercubeRoles, periodStartDate, periodEndDate) {
+function buildFormulaResolutionContext(formData, columns, sections, hypercubeRoles, periodStartDate, periodEndDate, typedMemberData) {
   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();
-  presentationRoles.forEach((role) => {
-    var _a;
-    const concepts = ((_a = role.presentationLinkbase) == null ? void 0 : _a.concepts) || [];
+  const columnsByRole = /* @__PURE__ */ new Map();
+  const roleURIByConceptId = /* @__PURE__ */ new Map();
+  sections.forEach((section2) => {
     const childrenIndex = /* @__PURE__ */ new Map();
-    concepts.forEach((concept) => indexConceptTree(concept, conceptByQName, conceptById, childrenIndex));
-    childrenByRole.set(role.roleURI, childrenIndex);
-    totalGroupChildrenByRole.set(role.roleURI, buildTotalGroupChildrenIndex(concepts, PRESENTATION_TOTAL_GROUP_ACCESSORS));
+    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));
+    for (const conceptId of childrenIndex.keys()) {
+      roleURIByConceptId.set(conceptId, section2.roleURI);
+    }
+    if (section2.columns)
+      columnsByRole.set(section2.roleURI, section2.columns);
   });
   const dimensionQNameToId = /* @__PURE__ */ new Map();
   const memberQNameToId = /* @__PURE__ */ new Map();
+  const memberChildrenByQName = /* @__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));
+        (dimension.members || []).forEach((member) => indexMemberTree(member, memberQNameToId, memberChildrenByQName));
       });
     });
   });
@@ -2775,11 +2822,16 @@ function buildFormulaResolutionContext(formData, columns, presentationRoles, hyp
     periodEndDate,
     conceptByQName,
     conceptById,
+    conceptIdByQNamePerRole,
     childrenByRole,
     totalGroupChildrenByRole,
     dimensionQNameToId,
     memberQNameToId,
-    allCandidates: collectAllCandidates(formData)
+    memberChildrenByQName,
+    columnsByRole,
+    roleURIByConceptId,
+    allCandidates: collectAllCandidates(formData),
+    typedMemberData: typedMemberData ?? {}
   };
 }
 function collectDescendantConceptIds(childrenIndex, rootConceptId) {
@@ -2800,10 +2852,13 @@ function candidateKey(candidate) {
   return `${candidate.conceptId}::${candidate.columnId}`;
 }
 function resolveMatchedCandidates(variable, ctx) {
-  return intersectCandidates(variable.filters.map((filter2) => resolveFilter(filter2, ctx.allCandidates, ctx)));
+  return intersectCandidates(variable.filters.map((filter2) => resolveFilter(filter2, ctx.allCandidates, ctx, variable.filters)));
 }
-function getColumn(ctx, columnId) {
-  return ctx.columns.find((column2) => column2.id === columnId);
+function getColumn(ctx, candidate) {
+  var _a;
+  const roleURI = ctx.roleURIByConceptId.get(candidate.conceptId);
+  const roleColumn = roleURI ? (_a = ctx.columnsByRole.get(roleURI)) == null ? void 0 : _a.find((column2) => column2.id === candidate.columnId) : void 0;
+  return roleColumn ?? ctx.columns.find((column2) => column2.id === candidate.columnId);
 }
 function columnMatchesExplicitDimension(column2, axisId, memberId) {
   if (!(column2 == null ? void 0 : column2.dimensionData))
@@ -2815,13 +2870,22 @@ function columnMatchesExplicitDimension(column2, axisId, memberId) {
     (combo) => combo.axisId === axisId && (memberId === void 0 || combo.memberId === memberId)
   );
 }
-function columnMatchesTypedDimension(column2, axisId) {
+function columnDeclaresTypedDimension(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 columnMatchesTypedDimension(ctx, candidate, axisId) {
+  const column2 = getColumn(ctx, candidate);
+  if (!columnDeclaresTypedDimension(column2, axisId))
+    return false;
+  const chosenValues = ctx.typedMemberData[candidate.columnId];
+  if (chosenValues === void 0)
+    return true;
+  return !!chosenValues[axisId];
+}
 function paramTokenName(rawDate) {
   if (!rawDate)
     return void 0;
@@ -2866,15 +2930,37 @@ function unionCandidates(lists) {
   lists.forEach((list) => list.forEach((candidate) => merged.set(candidateKey(candidate), candidate)));
   return Array.from(merged.values());
 }
-function matchFilter(filter2, universe, ctx) {
-  var _a;
+function resolveChildMemberAxisFilter(memberQName, axisId, universe, ctx, siblingFilters) {
+  var _a, _b;
+  const childMemberIds = ctx.memberChildrenByQName.get(memberQName) || [];
+  if (childMemberIds.length > 0) {
+    const matches = universe.filter(
+      (candidate) => childMemberIds.some((childId) => columnMatchesExplicitDimension(getColumn(ctx, candidate), axisId, childId))
+    );
+    if (matches.length > 0)
+      return matches;
+  }
+  const conceptRelationFilter = siblingFilters.find(
+    (sibling) => sibling.type === "CONCEPT_RELATION" && sibling.attributes["axis"] === "descendant"
+  );
+  const linkrole = conceptRelationFilter == null ? void 0 : conceptRelationFilter.attributes["linkrole"];
+  const anchorQName = conceptRelationFilter == null ? void 0 : conceptRelationFilter.attributes["qname"];
+  const anchorConceptId = anchorQName && linkrole ? (_a = ctx.conceptIdByQNamePerRole.get(linkrole)) == null ? void 0 : _a.get(anchorQName) : void 0;
+  const directChildren = new Set(anchorConceptId && linkrole ? ((_b = ctx.childrenByRole.get(linkrole)) == null ? void 0 : _b.get(anchorConceptId)) || [] : []);
+  if (directChildren.size === 0)
+    return [];
+  return universe.filter((candidate) => !directChildren.has(candidate.conceptId));
+}
+function matchFilter(filter2, universe, ctx, siblingFilters) {
+  var _a, _b;
   switch (filter2.type) {
     case "CONCEPT_NAME": {
       const qname = filter2.attributes["concept.qname"];
-      const info = qname ? ctx.conceptByQName.get(qname) : void 0;
-      if (!info)
+      const infos = qname ? ctx.conceptByQName.get(qname) : void 0;
+      if (!infos || infos.length === 0)
         return [];
-      return universe.filter((candidate) => candidate.conceptId === info.conceptId);
+      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"];
@@ -2887,16 +2973,16 @@ function matchFilter(filter2, universe, ctx) {
       const anchorQName = filter2.attributes["qname"];
       const linkrole = filter2.attributes["linkrole"];
       const axis = filter2.attributes["axis"];
-      const anchorInfo = anchorQName ? ctx.conceptByQName.get(anchorQName) : void 0;
+      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 (!anchorInfo || !childrenIndex)
+      if (!anchorConceptId || !childrenIndex)
         return [];
       let relatedConceptIds;
       if (axis === "descendant") {
-        relatedConceptIds = collectDescendantConceptIds(childrenIndex, anchorInfo.conceptId);
+        relatedConceptIds = collectDescendantConceptIds(childrenIndex, anchorConceptId);
       } else {
-        const nestedChildren = childrenIndex.get(anchorInfo.conceptId) || [];
-        relatedConceptIds = nestedChildren.length > 0 ? nestedChildren : ((_a = ctx.totalGroupChildrenByRole.get(linkrole ?? "")) == null ? void 0 : _a.get(anchorInfo.conceptId)) || [];
+        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));
@@ -2905,31 +2991,38 @@ function matchFilter(filter2, universe, ctx) {
       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));
+      if (memberQName && filter2.attributes["member.axis"] === "child") {
+        return resolveChildMemberAxisFilter(memberQName, axisId, universe, ctx, siblingFilters);
+      }
+      const memberId = memberQName ? ctx.memberQNameToId.get(memberQName) : void 0;
+      return universe.filter((candidate) => columnMatchesExplicitDimension(getColumn(ctx, candidate), 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));
+      return universe.filter((candidate) => columnMatchesTypedDimension(ctx, candidate, axisId));
     }
     case "PERIOD_INSTANT":
     case "PERIOD_END": {
       const dateAttribute = filter2.attributes["date"];
-      return universe.filter((candidate) => columnMatchesPeriod(getColumn(ctx, candidate.columnId), dateAttribute, ctx));
+      return universe.filter((candidate) => columnMatchesPeriod(getColumn(ctx, candidate), dateAttribute, ctx));
     }
     case "OR_FILTER":
-      return unionCandidates(filter2.children.map((child) => resolveFilter(child, universe, ctx)));
+      return unionCandidates(filter2.children.map((child) => resolveFilter(child, universe, ctx, siblingFilters)));
+    case "ASPECT_COVER":
+      return universe;
+    case "UNKNOWN":
+      return universe;
     default:
       return [];
   }
 }
-function resolveFilter(filter2, universe, ctx) {
-  const matched = matchFilter(filter2, universe, ctx);
+function resolveFilter(filter2, universe, ctx, siblingFilters) {
+  const matched = matchFilter(filter2, universe, ctx, siblingFilters);
   if (!filter2.complement)
     return matched;
   const matchedKeys = new Set(matched.map(candidateKey));
@@ -2943,12 +3036,63 @@ function intersectCandidates(sets) {
     return acc.filter((candidate) => setKeys.has(candidateKey(candidate)));
   });
 }
+function resolveRawValue(raw) {
+  if (raw === void 0 || raw === null || raw === "")
+    return void 0;
+  const numeric = parseFloat(String(raw));
+  return Number.isNaN(numeric) ? String(raw) : numeric;
+}
+function hasExplicitPeriodFilter(filters) {
+  return filters.some((filter2) => {
+    if (filter2.type === "PERIOD_INSTANT" || filter2.type === "PERIOD_END")
+      return true;
+    if (filter2.type === "OR_FILTER")
+      return hasExplicitPeriodFilter(filter2.children);
+    return false;
+  });
+}
+function narrowToCurrentPeriod(candidates, variable, ctx) {
+  if (candidates.length <= 1 || hasExplicitPeriodFilter(variable.filters))
+    return candidates;
+  const currentPeriodOnly = candidates.filter(
+    (candidate) => columnEffectivePeriod(getColumn(ctx, candidate), ctx).end === ctx.periodEndDate
+  );
+  return currentPeriodOnly.length > 0 ? currentPeriodOnly : candidates;
+}
+function narrowByPreferredOccurrence(candidates, ctx) {
+  const groups = /* @__PURE__ */ new Map();
+  candidates.forEach((candidate) => {
+    var _a;
+    const qname = ((_a = ctx.conceptById.get(candidate.conceptId)) == null ? void 0 : _a.qname) ?? candidate.conceptId;
+    const key = `${candidate.columnId}::${qname}`;
+    const group = groups.get(key);
+    if (group)
+      group.push(candidate);
+    else
+      groups.set(key, [candidate]);
+  });
+  const result = [];
+  groups.forEach((group) => {
+    if (group.length <= 1) {
+      result.push(...group);
+      return;
+    }
+    const roles = group.map((candidate) => {
+      var _a;
+      return (_a = ctx.conceptById.get(candidate.conceptId)) == null ? void 0 : _a.effectivePeriodRole;
+    });
+    const endLabelOnly = group.filter((_candidate, index) => roles[index] === "periodEndLabel");
+    const isAmbiguous = new Set(roles).size > 1;
+    result.push(...isAmbiguous && endLabelOnly.length > 0 ? endLabelOnly : group);
+  });
+  return result;
+}
 function resolveFormulaVariable(variable, ctx) {
-  const matched = resolveMatchedCandidates(variable, ctx);
+  const matched = narrowByPreferredOccurrence(narrowToCurrentPeriod(resolveMatchedCandidates(variable, ctx), variable, ctx), 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));
+    return resolveRawValue((_a = ctx.formData[candidate.conceptId]) == null ? void 0 : _a[candidate.columnId]);
+  }).filter((value) => value !== void 0);
   if (variable.bindAsSequence) {
     if (values.length === 0 && variable.fallbackValue === "()")
       return [];
@@ -2968,6 +3112,15 @@ function resolveFormulaVariable(variable, ctx) {
 function resolveFormulaVariableMatchCount(variable, ctx) {
   return resolveMatchedCandidates(variable, ctx).length;
 }
+function resolveFormulaVariableSetMatchCount(variables, ctx) {
+  const merged = /* @__PURE__ */ new Map();
+  for (const variable of variables) {
+    for (const candidate of resolveMatchedCandidates(variable, ctx)) {
+      merged.set(candidateKey(candidate), candidate);
+    }
+  }
+  return merged.size;
+}
 function resolveFormulaVariableUsedFallback(variable, ctx) {
   const matchCount = resolveFormulaVariableMatchCount(variable, ctx);
   if (matchCount > 0)
@@ -2976,6 +3129,27 @@ function resolveFormulaVariableUsedFallback(variable, ctx) {
     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, variable.filters)));
+  return resolved.map((candidate) => candidate.columnId);
+}
 function buildAssertionBindings(assertion, ctx) {
   const bindings = /* @__PURE__ */ new Map();
   for (const variable of assertion.variables) {
@@ -2996,6 +3170,14 @@ function buildAssertionFallbackUsage(assertion, ctx) {
   }
   return fallbackUsage;
 }
+function checkAllVariablesBound(assertion, bindings) {
+  for (const variable of assertion.variables) {
+    if (bindings.get(variable.name) === void 0) {
+      return { satisfied: false, skipReason: "unresolvable" };
+    }
+  }
+  return { satisfied: true };
+}
 function evaluateAssertionPreconditions(preconditions, bindings, fallbackUsage = /* @__PURE__ */ new Map()) {
   if (preconditions.length === 0)
     return { satisfied: true };
@@ -3066,18 +3248,24 @@ class FormulaValidationService {
   _evaluateAssertion(assertion, role, ctx, language) {
     try {
       const bindings = buildAssertionBindings(assertion, ctx);
+      if (assertion.type === "VALUE_ASSERTION") {
+        const bindingCheck = checkAllVariablesBound(assertion, bindings);
+        if (!bindingCheck.satisfied) {
+          return this._skippedResult(assertion, role, bindingCheck.skipReason ?? "unresolvable");
+        }
+      }
       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 matchedFactCount = assertion.variables.length === 1 ? resolveFormulaVariableMatchCount(assertion.variables[0], ctx) : resolveFormulaVariableSetMatchCount(assertion.variables, ctx);
         const satisfied2 = evaluateExistenceTest(assertion.test, matchedFactCount);
-        return this._evaluatedResult(assertion, role, satisfied2, language, matchedFactCount);
+        return this._evaluatedResult(assertion, role, ctx, satisfied2, language, matchedFactCount);
       }
       const satisfied = evaluateFormulaTest(assertion.test, bindings, fallbackUsage);
-      return this._evaluatedResult(assertion, role, satisfied, language);
+      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}`);
@@ -3098,7 +3286,8 @@ class FormulaValidationService {
       skipReason
     };
   }
-  _evaluatedResult(assertion, role, satisfied, language, matchedFactCount) {
+  _evaluatedResult(assertion, role, ctx, satisfied, language, matchedFactCount) {
+    const message = satisfied ? void 0 : this._pickMessage(assertion, language);
     return {
       assertionId: assertion.id,
       roleURI: role.roleURI,
@@ -3107,8 +3296,9 @@ class FormulaValidationService {
       severity: assertion.severity,
       satisfied,
       skipped: false,
-      message: satisfied ? void 0 : this._pickMessage(assertion, language),
-      matchedFactCount
+      message,
+      matchedFactCount,
+      conceptLinks: message ? this._buildConceptLinks(assertion, role.roleURI, ctx, message) : void 0
     };
   }
   _pickMessage(assertion, language) {
@@ -3116,7 +3306,55 @@ class FormulaValidationService {
     if (messages.length === 0)
       return void 0;
     const message = messages.find((m) => m.xmlLang === language) ?? messages.find((m) => m.xmlLang === "en") ?? messages[0];
-    return message.text;
+    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 {
@@ -6162,15 +6400,33 @@ JupiterConceptTree.styles = css`
     /* Row-level highlight while a field in this row has focus. Applied to every
        cell so the row stays identifiable even after the user scrolls the table
        horizontally away from the focused input. */
-    .concept-name-cell.row-focused,
     .field-cell.row-focused {
       background: var(--jupiter-row-focus-background, rgba(25, 118, 210, 0.14));
     }
 
+    /* .concept-name-cell is position:sticky with left:0, so it renders on top of
+       field-cells that have scrolled underneath it as the user tabs across columns.
+       It must stay fully opaque, or that translucent tint lets the scrolled-under
+       cells' content (inputs, icons) show through and visually overlap with this
+       cell's label/badge. Layer the tint as a background-image over an explicit
+       opaque background-color instead of replacing the background outright. */
     .concept-name-cell.row-focused {
+      background-image: linear-gradient(
+        var(--jupiter-row-focus-background, rgba(25, 118, 210, 0.14)),
+        var(--jupiter-row-focus-background, rgba(25, 118, 210, 0.14))
+      );
+      background-color: var(--jupiter-concept-background, #f8f9fa);
       box-shadow: inset 3px 0 0 0 var(--jupiter-primary-color, #1976d2);
     }
 
+    .concept-name-cell.abstract.row-focused {
+      background-color: var(--bg-color-1, var(--jupiter-abstract-background, #f0f2f5));
+    }
+
+    .concept-name-cell.leaf.row-focused {
+      background-color: var(--bg-color-2, var(--jupiter-leaf-background, #fff));
+    }
+
     .concept-info-btn {
       flex-shrink: 0;
       width: 22px;
@@ -10290,6 +10546,35 @@ let JupiterFormulaValidationDialog = class extends LitElement {
     }
     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;
@@ -10338,7 +10623,7 @@ let JupiterFormulaValidationDialog = class extends LitElement {
                         <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">${result.message}</span>
+                        <span class="assertion-message">${this._renderMessage(result)}</span>
                       </div>
                     `)}
                   </div>
@@ -10533,6 +10818,23 @@ JupiterFormulaValidationDialog.styles = css`
       line-height: 1.4;
     }
 
+    .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;
+    }
+
+    .concept-link:hover {
+      opacity: 0.8;
+    }
+
     .dialog-actions {
       display: flex;
       gap: 12px;
@@ -11381,6 +11683,14 @@ let JupiterDynamicForm = class extends LitElement {
   _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, event.detail.conceptId);
+  }
   _handleRoleFilterApply(event) {
     var _a, _b;
     const { selectedRoleIds, periodPreferences } = event.detail;
@@ -12519,7 +12829,6 @@ let JupiterDynamicForm = class extends LitElement {
       return;
     }
     this._correctLegacyPeriodStartInstantDates();
-    this._runFormulaValidationPreflight();
     const submissionData = this._generateSubmissionData();
     console.log("📊 Form Submission Data:", JSON.stringify(submissionData, null, 2));
     console.log("📊 Submission Data Summary:");
@@ -12541,6 +12850,16 @@ 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
@@ -12550,21 +12869,44 @@ let JupiterDynamicForm = class extends LitElement {
    * cost when off" requirement).
    */
   _runFormulaValidationPreflight() {
-    var _a, _b, _c, _d, _e, _f, _g, _h, _i;
+    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,
+        columns: section2.columns
+      };
+    });
     const ctx = buildFormulaResolutionContext(
       this._formData,
       this._mergeAllSectionColumns(),
-      ((_f = (_e = (_d = this.xbrlInput) == null ? void 0 : _d.presentation) == null ? void 0 : _e[0]) == null ? void 0 : _f.roles) || [],
-      (_i = (_h = (_g = this.xbrlInput) == null ? void 0 : _g.hypercubes) == null ? void 0 : _h[0]) == null ? void 0 : _i.roles,
+      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
+      this.periodEndDate,
+      this._typedMemberData
     );
-    const results = this._formulaValidationService.evaluate(this.xbrlInput, ctx, this.language);
+    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;
@@ -14712,6 +15054,59 @@ let JupiterDynamicForm = class extends LitElement {
     }
     return null;
   }
+  // Same taxonomy concept can be placed at multiple points in a role's presentation tree
+  // with different preferred labels (e.g. a rollforward's periodStartLabel/periodEndLabel
+  // rows) — each such occurrence gets its own ConceptTree row/id. Unlike _findConceptByName,
+  // this collects every matching row (DFS order) so the caller can disambiguate between them
+  // instead of always taking the first one found.
+  _findAllConceptsByName(concepts, name) {
+    var _a;
+    const localName = name.includes(":") ? name.split(":").pop() : name;
+    const matches = [];
+    for (const c2 of concepts) {
+      const cLocal = c2.name.includes(":") ? c2.name.split(":").pop() : c2.name;
+      if (c2.name === name || cLocal === localName)
+        matches.push(c2);
+      if ((_a = c2.children) == null ? void 0 : _a.length) {
+        matches.push(...this._findAllConceptsByName(c2.children, name));
+      }
+    }
+    return matches;
+  }
+  _findConceptById(concepts, id) {
+    var _a;
+    for (const c2 of concepts) {
+      if (c2.id === id)
+        return c2;
+      if ((_a = c2.children) == null ? void 0 : _a.length) {
+        const hit = this._findConceptById(c2.children, id);
+        if (hit)
+          return hit;
+      }
+    }
+    return null;
+  }
+  // Loose value comparison used to disambiguate rows that share a concept name: exact
+  // string match, numeric equality, or numeric equality up to a power-of-ten scale
+  // (the form may store a display value while the caller passes the raw XBRL value).
+  _valueLooselyMatches(fieldValue, targetValue) {
+    const fv = String(fieldValue ?? "");
+    if (fv === targetValue)
+      return true;
+    const fNum = Number(fv);
+    const tNum = Number(targetValue);
+    if (isNaN(fNum) || isNaN(tNum))
+      return false;
+    if (fNum === tNum)
+      return true;
+    if (fNum !== 0 && tNum !== 0) {
+      const ratio = Math.abs(tNum / fNum);
+      const log = Math.log10(ratio);
+      if (Math.abs(log - Math.round(log)) < 1e-4)
+        return true;
+    }
+    return false;
+  }
   _findColumnByDimensions(columns, dims) {
     var _a;
     return (_a = columns.find((col) => {
@@ -14728,9 +15123,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, exactConceptId) {
     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} exactConceptId=${exactConceptId}`);
     let targetSection = null;
     let targetConcept = null;
     const sectionsToSearch = [
@@ -14741,14 +15136,62 @@ let JupiterDynamicForm = class extends LitElement {
       })
     ];
     console.log(`[scrollToConcept] Searching ${sectionsToSearch.length} sections`);
-    for (const section2 of sectionsToSearch) {
-      const found = this._findConceptByName(section2.concepts, conceptName);
-      if (found) {
-        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(",")}`);
-          if (colId) {
+    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 (exactConceptId) {
+      for (const section2 of sectionsToSearch) {
+        const found = this._findConceptById(section2.concepts, exactConceptId);
+        if (found) {
+          console.log(`[scrollToConcept] Section "${section2.id}" matched exactConceptId="${exactConceptId}"`);
+          targetSection = section2;
+          targetConcept = found;
+          break;
+        }
+      }
+    }
+    if (!targetSection || !targetConcept) {
+      for (const section2 of sectionsToSearch) {
+        const candidates = this._findAllConceptsByName(section2.concepts, conceptName);
+        if (!candidates.length)
+          continue;
+        const cols = section2.columns ?? this._columns;
+        const resolvedColumnId = columnId ?? ((dimensions == null ? void 0 : dimensions.length) ? this._findColumnByDimensions(cols, dimensions) : void 0);
+        let picked;
+        if (candidates.length > 1) {
+          picked = candidates.find((c2) => {
+            const rowData = this._formData[c2.id];
+            if (!rowData)
+              return false;
+            if (resolvedColumnId) {
+              const cellValue = rowData[resolvedColumnId];
+              if (cellValue === void 0 || cellValue === null || cellValue === "")
+                return false;
+              return !hasValueMatch || this._valueLooselyMatches(cellValue, targetValue);
+            }
+            if (hasValueMatch) {
+              return Object.values(rowData).some(
+                (v) => v !== void 0 && v !== null && v !== "" && this._valueLooselyMatches(v, targetValue)
+              );
+            }
+            return false;
+          });
+          console.log(`[scrollToConcept] Section "${section2.id}" has ${candidates.length} rows named "${conceptName}" | disambiguated=${(picked == null ? void 0 : picked.id) ?? "none (using first)"}`);
+        }
+        const found = picked ?? candidates[0];
+        if (columnId) {
+          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) {
+          console.log(`[scrollToConcept] Section "${section2.id}" has concept "${found.id}" | colMatch=${resolvedColumnId ?? "null"} | cols=${cols.map((c2) => c2.id).join(",")}`);
+          if (resolvedColumnId) {
             targetSection = section2;
             targetConcept = found;
             break;
@@ -14775,9 +15218,9 @@ let JupiterDynamicForm = class extends LitElement {
     }
     const columns = targetSection.columns ?? this._columns;
     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;
@@ -15023,6 +15466,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"
@@ -15060,6 +15512,7 @@ let JupiterDynamicForm = class extends LitElement {
             .results="${this._formulaValidationResults}"
             .summary="${this._formulaValidationSummary}"
             @dialog-cancel="${this._handleFormulaValidationDialogCancel}"
+            @formula-concept-click="${this._handleFormulaConceptClick}"
             @click="${this._handleFormulaValidationDialogCancel}"
           ></jupiter-formula-validation-dialog>
         ` : ""}